Inheritance

Codables handles inheritance seamlessly.

On every level of the hierarchy, only properties marked with @codable() are encoded.

Basic Inheritance


@codableClass("Animal")
class Animal {
  @codable() name: string;
  @codable() age: number;
 
  constructor(data: Memberwise<Animal>) {
    this.name = data.name;
    this.age = data.age;
  }
}
 
@codableClass("Dog", { dependencies: [Animal] })
class Dog extends Animal {
  @codable() breed: string;
  @codable() tricks: Set<string>;
 
  constructor(data: Memberwise<Dog>) {
    super({ name: data.name, age: data.age });
    this.breed = data.breed;
    this.tricks = data.tricks;
  }
}
 
const coder = new Coder([Dog]);
 
const dog = new Dog({
  name: "Buddy",
  age: 3,
  breed: "Golden Retriever", 
  tricks: new Set(["sit", "stay", "roll over"])
});
 
const encoded = coder.encode(dog);
/**
 * { 
 *   $$Dog: [
 *     {
 *       name: "Buddy",
 *       age: 3,
 *       breed: "Golden Retriever",
 *       tricks: { $$Set: ["sit", "stay", "roll over"] }
 *     }
 *   ]
 * }
 */
 
const decoded = coder.decode<Dog>(encoded);
// decoded instanceof Dog === true
// decoded.name === "Buddy" (from parent class)
// decoded.breed === "Golden Retriever" (from child class)

We’ve declared dependencies in the example above. It is not required, but allows you to make each class declare its own dependencies instead of having some central place where you collect all of custom types.

Multi-Level Inheritance

Inheritance works across multiple levels:


@codableClass("Vehicle")
class Vehicle {
  @codable() make: string;
  @codable() model: string;
  @codable() year: number;
 
  constructor(data: Memberwise<Vehicle>) {
    this.make = data.make;
    this.model = data.model;
    this.year = data.year;
  }
}
 
@codableClass("Car", { dependencies: [Vehicle] })
class Car extends Vehicle {
  @codable() doors: number;
  @codable() fuelType: string;
 
  constructor(data: Memberwise<Car>) {
    super({ make: data.make, model: data.model, year: data.year });
    this.doors = data.doors;
    this.fuelType = data.fuelType;
  }
}
 
@codableClass("ElectricCar", { dependencies: [Car] })
class ElectricCar extends Car {
  @codable() batteryCapacity: number;
  @codable() chargingPorts: Set<string>;
 
  constructor(data: Memberwise<ElectricCar>) {
    super(data);
    this.batteryCapacity = data.batteryCapacity;
    this.chargingPorts = data.chargingPorts;
  }
}
 
const coder = new Coder([ElectricCar]);
 
const tesla = new ElectricCar({
  make: "Tesla",
  model: "Model 3",
  year: 2023,
  doors: 4,
  fuelType: "electric",
  batteryCapacity: 75,
  chargingPorts: new Set(["Type 2", "CCS"])
});
 
const encoded = coder.encode(tesla);
// All properties from all levels are encoded