Better types for immutables (#16)

* Stricter types for immutables

* Moar goodies

* moar

Author: Sébastien

src/base-immutable/base-immutable.spec.ts

@@ -131,7 +131,7 @@ describe('BaseImmutable', () => {
             name: 'focus2',
           },
         },
-      } as any);
+      });
 
       const newCar = car.deepChange('subCar.subCar', { name: 'anuford' });
       expect(newCar.deepGet('subCar.subCar.name')).toEqual('anuford');
@@ -233,7 +233,7 @@ describe('BaseImmutable', () => {
           name: 'focus2',
         },
       },
-    } as any);
+    });
     expect(car.deepGet('subCar.subCar.name')).toEqual('focus2');
   });
 
@@ -242,12 +242,26 @@ describe('BaseImmutable', () => {
       fuel: 'electric',
       name: 'ford',
       owners: [],
-    } as any);
+    });
 
     expect(car.toJS()).toEqual({
       fuel: 'electric',
       name: 'ford',
       owners: [],
     });
   });
+
+  it('works with types', () => {
+    const car = Car.fromJS({
+      fuel: 'electric',
+      name: 'ford',
+    });
+
+    // should pass TS transpilation
+    car.change('owners', ['foo']);
+
+    // should NOT pass TS transpilation
+    // car.change('owners', 'foo');
+    // car.change('some unknown prop', ['hello']);
+  });
 });

src/base-immutable/base-immutable.ts

@@ -43,8 +43,8 @@ export const PropertyType = {
   ARRAY: 'array' as PropertyType,
 };
 
-export interface Property {
-  name: string;
+export interface Property<T extends { [key: string]: any } = any> {
+  name: keyof T;
   defaultValue?: any;
   possibleValues?: any[];
   validate?: Validator | Validator[];
@@ -82,8 +82,8 @@ export abstract class BaseImmutable<ValueType, JSType>
   // This needs to be defined
   // abstract static PROPERTIES: Property[];
 
-  static jsToValue(
-    properties: Property[],
+  static jsToValue<T = any>(
+    properties: Property<T>[],
     js: any,
     backCompats?: BackCompat[],
     context?: Record<string, any>,
@@ -222,16 +222,16 @@ export abstract class BaseImmutable<ValueType, JSType>
     }
   }
 
-  public ownProperties(): Property[] {
+  public ownProperties(): Property<ValueType>[] {
     return (this.constructor as any).PROPERTIES;
   }
 
-  public findOwnProperty(propName: string): Property | undefined {
+  public findOwnProperty(propName: keyof ValueType): Property | undefined {
     const properties = this.ownProperties();
     return NamedArray.findByName(properties, propName);
   }
 
-  public hasProperty(propName: string): boolean {
+  public hasProperty(propName: keyof ValueType): boolean {
     return this.findOwnProperty(propName) !== null;
   }
 
@@ -319,27 +319,30 @@ export abstract class BaseImmutable<ValueType, JSType>
     return true;
   }
 
-  public get(propName: string): any {
+  public get<T extends keyof ValueType>(propName: T): ValueType[T] {
     const getter = (this as any)['get' + firstUp(propName)];
     if (!getter) throw new Error(`can not find prop ${propName}`);
     return getter.call(this);
   }
 
-  public change(propName: string, newValue: any): this {
+  public change<T extends keyof ValueType>(propName: T, newValue: ValueType[T]): this {
     const changer = (this as any)['change' + firstUp(propName)];
     if (!changer) throw new Error(`can not find prop ${propName}`);
     return changer.call(this, newValue);
   }
 
-  public changeMany(properties: Record<string, any>): this {
+  public changeMany(properties: Partial<ValueType>): this {
     if (!properties) throw new TypeError('Invalid properties object');
 
     let o = this;
 
     for (const propName in properties) {
       if (!this.hasProperty(propName)) throw new Error('Unknown property: ' + propName);
 
-      o = o.change(propName, properties[propName]);
+      // Added ! because TypeScript thinks a Partial can have undefined properties
+      // (which they can and it's cool)
+      // https://github.com/Microsoft/TypeScript/issues/13195
+      o = o.change(propName, properties[propName]!);
     }
 
     return o;

src/base-immutable/car.mock.ts

@@ -47,6 +47,8 @@ export interface CarValue {
   range?: number;
   relatedCars?: Car[];
   createdOn?: Date;
+  owners?: string[];
+  driver?: Driver;
 }
 
 export interface CarJS {
@@ -56,14 +58,16 @@ export interface CarJS {
   range?: number;
   relatedCars?: CarJS[];
   createdOn?: Date | string;
+  owners?: string[];
+  driver?: DriverJS;
 }
 
 function ensureNonNegative(n: any): void {
   if (n < 0) throw new Error('must non negative positive');
 }
 
 export class Car extends BaseImmutable<CarValue, CarJS> {
-  static PROPERTIES: Property[] = [
+  static PROPERTIES: Property<CarValue>[] = [
     {
       name: 'name',
       validate: (n: string) => {

tsconfig.json

@@ -14,9 +14,8 @@
     "target": "es5",
     "rootDir": "src",
     "outDir": "build",
-    "moduleResolution": "node"
+    "moduleResolution": "node",
+    "keyofStringsOnly": true
   },
-  "include": [
-    "src/**/*.ts"
-  ]
+  "include": ["src/**/*.ts"]
 }