Merge pull request #40 from nobrainr/feat/support-inferred-types

Feat/support inferred types

Author: emyann

src/morphism.spec.ts

@@ -1,4 +1,4 @@
-import Morphism from './morphism';
+import Morphism, { StrictSchema } from './morphism';
 
 class User {
   firstName: string;
@@ -29,7 +29,28 @@ class User {
 }
 
 describe('Morphism', () => {
-  const dataToCrunch = [
+  interface MockData {
+    firstName: string;
+    lastName: string;
+    age: number;
+    address: {
+      streetAddress: string;
+      city: string;
+      state: string;
+      postalCode: string;
+    };
+    phoneNumber: [
+      {
+        type: string;
+        number: string;
+      },
+      {
+        type: string;
+        number: string;
+      }
+    ];
+  }
+  const dataToCrunch: MockData[] = [
     {
       firstName: 'John',
       lastName: 'Smith',
@@ -200,7 +221,7 @@ describe('Morphism', () => {
     describe('Function Predicate', function() {
       it('should support es6 destructuring as function predicate', function() {
         let schema = {
-          target: ({ source }: any) => source
+          target: ({ source }: { source: string }) => source
         };
         let mock = {
           source: 'value'
@@ -210,6 +231,7 @@ describe('Morphism', () => {
         };
         let result = Morphism(schema, mock);
         expect(result).toEqual(expected);
+        expect(result.target).toEqual(expected.target);
       });
 
       it('should support nesting mapping', function() {
@@ -348,11 +370,18 @@ describe('Morphism', () => {
     });
 
     it('should pass the object value to the function when no path is specified', function() {
-      let schema = {
+      interface D {
+        firstName: string;
+        lastName: string;
+        city: string;
+        status: string;
+      }
+
+      let schema: StrictSchema<D, MockData> = {
         firstName: 'firstName',
         lastName: 'lastName',
-        city: 'address.city',
-        status: (o: any) => o.phoneNumber[0].type
+        city: { path: 'address.city', fn: prop => prop },
+        status: o => o.phoneNumber[0].type
       };
 
       let desiredResult = {

src/morphism.ts

@@ -3,9 +3,6 @@
  */
 import { isString, get, isFunction, zipObject, isUndefined, assignInWith, aggregator, isObject } from './helpers';
 
-export function isActionSelector(value: any): value is ActionSelector {
-  return isObject(value);
-}
 /**
  * A Function invoked per iteration
  * @param {} iteratee The current element to transform
@@ -31,8 +28,8 @@ export function isActionSelector(value: any): value is ActionSelector {
  * ```
  *
  */
-export interface ActionFunction<D, S> {
-  (iteratee: S, source: S[], target: D): any;
+export interface ActionFunction<D, S, R> {
+  (iteratee: S, source: S[], target: D): R;
 }
 /**
  * A String path that indicates where to find the property in the source input
@@ -100,7 +97,7 @@ export type ActionAggregator = string[];
  *```
  *
  */
-export type ActionSelector = { path: string | string[]; fn: (fieldValue: any, items: any[]) => any };
+export type ActionSelector<Source, R> = { path: string | string[]; fn: (fieldValue: any, items: Source[]) => R };
 
 /**
  * A structure-preserving object from a source data towards a target data.
@@ -134,23 +131,25 @@ export type ActionSelector = { path: string | string[]; fn: (fieldValue: any, it
  * ```
  */
 
-export type StrictSchema<Target = {}, Source = any> = {
+export type StrictSchema<Target = any, Source = any> = {
   /** `destinationProperty` is the name of the property of the target object you want to produce */
   [destinationProperty in keyof Target]:
     | ActionString<Source>
-    | ActionFunction<Target, Source>
+    | ActionFunction<Target, Source, Target[destinationProperty]>
     | ActionAggregator
-    | ActionSelector
+    | ActionSelector<Source, Target[destinationProperty]>
 };
-export type Schema<Target = {}, Source = any> = {
+export type Schema<Target = any, Source = any> = {
   /** `destinationProperty` is the name of the property of the target object you want to produce */
   [destinationProperty in keyof Target]?:
     | ActionString<Source>
-    | ActionFunction<Target, Source>
+    | ActionFunction<Target, Source, Target[destinationProperty]>
     | ActionAggregator
-    | ActionSelector
+    | ActionSelector<Source, Target[destinationProperty]>
 };
-
+export function isActionSelector<S, R>(value: any): value is ActionSelector<S, R> {
+  return isObject(value);
+}
 /**
  * Low Level transformer function.
  * Take a plain object as input and transform its values using a specified schema.
@@ -218,11 +217,6 @@ interface Constructable<T> {
   new (...args: any[]): T;
 }
 
-export interface Mapper<Target> {
-  <Source>(source: Source[]): Target[];
-  <Source>(source: Source): Target;
-}
-
 function transformItems<T, TSchema extends Schema<T>>(schema: TSchema): Mapper<{ [P in keyof TSchema]: any }>;
 function transformItems<T, TSchema extends Schema<T>>(
   schema: TSchema,
@@ -266,6 +260,15 @@ function getSchemaForType<T>(type: Constructable<T>, baseSchema: Schema<T>): Sch
   return finalSchema;
 }
 
+type SourceFromSchema<T> = T extends StrictSchema<unknown, infer U> | Schema<unknown, infer U> ? U : never;
+type DestinationFromSchema<T> = T extends StrictSchema<infer U> | Schema<infer U> ? U : never;
+
+type ResultItem<TSchema extends Schema> = { [P in keyof TSchema]: DestinationFromSchema<TSchema>[P] };
+export interface Mapper<TSchema extends Schema | StrictSchema, TResult = ResultItem<TSchema>> {
+  (data: Partial<SourceFromSchema<TSchema>>[]): TResult[];
+  (data: Partial<SourceFromSchema<TSchema>>): TResult;
+}
+
 /**
  * Currying function that either outputs a mapping function or the transformed data.
  *
@@ -288,28 +291,35 @@ function getSchemaForType<T>(type: Constructable<T>, baseSchema: Schema<T>): Sch
  * @param  {} type
  *
  */
-export function morphism<TSchema extends Schema<{}, Source>, Source>(
+export function morphism<TSchema extends Schema, Source extends SourceFromSchema<TSchema>>(
   schema: TSchema,
-  items: Source
-): Source extends any[] ? { [P in keyof TSchema]: any }[] : { [P in keyof TSchema]: any };
-// morphism({},{}) => {}
-// morphism({},[]) => Target[]
+  data: Source
+): Source extends any[] ? ResultItem<TSchema>[] : ResultItem<TSchema>;
 
-export function morphism<TSchema extends Schema<any>>(schema: TSchema): Mapper<{ [P in keyof TSchema]: any }>; // morphism(TSchema) => mapper(S[]) => (keyof TSchema)[]
-export function morphism<Target>(schema: Schema<Target>): Mapper<Target>; // morphism<ITarget>({}) => Mapper<ITarget> => ITarget
-export function morphism<Target, Source>(
-  schema: Schema<Target>,
+export function morphism<TSchema extends Schema, Source extends SourceFromSchema<TSchema>>(
+  schema: TSchema,
+  data: Source[]
+): ResultItem<TSchema>[];
+
+export function morphism<TSchema extends Schema>(schema: TSchema): Mapper<TSchema>; // morphism({}) => mapper(S) => T
+
+export function morphism<TSchema extends Schema, TDestination>(
+  schema: TSchema,
   items: null,
+  type: Constructable<TDestination>
+): Mapper<TSchema, TDestination>; // morphism({}, null, T) => mapper(S) => T
+
+export function morphism<TSchema extends Schema, Target>(
+  schema: TSchema,
+  items: SourceFromSchema<TSchema>,
   type: Constructable<Target>
-): Mapper<Target>; // morphism({}, null, T) => mapper(S) => T
-export function morphism<Target, Source>(
-  schema: Schema<Target>,
-  items: Source[],
-  type: Constructable<Target>
-): Target[]; // morphism({}, [], T) => T[]
-export function morphism<Target, Source>(schema: Schema<Target>, items: Source, type: Constructable<Target>): Target; // morphism({}, {}, T) => T
+): Target; // morphism({}, {}, T) => T
 
-export function morphism<Target, Source>(schema: Schema<Target>, items?: Source, type?: Constructable<Target>) {
+export function morphism<Target, Source, TSchema extends Schema<Target, Source>>(
+  schema: TSchema,
+  items?: SourceFromSchema<TSchema>,
+  type?: Constructable<Target>
+): any {
   if (items === undefined && type === undefined) {
     return transformItems(schema);
   } else if (schema && items && type) {
@@ -336,15 +346,15 @@ export interface IMorphismRegistry {
    * @param schema Structure-preserving object from a source data towards a target data.
    *
    */
-  register<Target, TSchema extends Schema<Target>>(type: Constructable<Target>, schema?: TSchema): Mapper<Target>;
+  register<Target, TSchema>(type: Constructable<Target>, schema?: TSchema): Mapper<TSchema, Target>;
   /**
    * Transform any input in the specified Class
    *
    * @param {Type} type Class Type of the ouput Data
    * @param {Object} data Input data to transform
    *
    */
-  map<Target>(type: Target): Mapper<Target>;
+  map<Target>(type: Target): Mapper<Schema, Target>;
   map<Target, Source>(type: Constructable<Target>, data: Source[]): Target[];
   map<Target, Source>(type: Constructable<Target>, data: Source): Target;
   /**
@@ -353,15 +363,15 @@ export interface IMorphismRegistry {
    * @param {Type} type Class Type of the ouput Data
    *
    */
-  getMapper<Target>(type: Constructable<Target>): Mapper<Target>;
+  getMapper<Target>(type: Constructable<Target>): Mapper<Schema, Target>;
   /**
    * Set a schema for a specific Class Type
    *
    * @param {Type} type Class Type of the ouput Data
    * @param {Schema} schema Class Type of the ouput Data
    *
    */
-  setMapper<Target, TSchema extends Schema<Target>>(type: Constructable<Target>, schema: TSchema): Mapper<Target>;
+  setMapper<Target, TSchema extends Schema<Target>>(type: Constructable<Target>, schema: TSchema): Mapper<any, Target>;
   /**
    * Delete a registered schema associated to a Class
    *
@@ -405,7 +415,7 @@ export class MorphismRegistry implements IMorphismRegistry {
    * @param schema Structure-preserving object from a source data towards a target data.
    *
    */
-  register<Target, TSchema extends Schema<Target>>(type: Constructable<Target>, schema?: TSchema) {
+  register<Target, TSchema>(type: Constructable<Target>, schema?: TSchema) {
     if (!type && !schema) {
       throw new Error('type paramater is required when register a mapping');
     } else if (this.exists(type)) {

src/typescript.spec.ts

@@ -13,14 +13,19 @@ describe('Morphism', () => {
         fooB: string;
         fooC: string;
       }
-      const schema = {
+      const schema: StrictSchema<Destination, Source> = {
         fooA: 'inputA',
         fooB: ({ inputB }) => inputB,
         fooC: 'inputC'
-      } as StrictSchema<Destination, Source>;
+      };
 
       const mapper = morphism(schema);
-      const res = mapper({}) as Destination;
+
+      expect(mapper({ inputA: 'test', inputB: 'test2', inputC: 'test3' })).toEqual({
+        fooA: 'test',
+        fooB: 'test2',
+        fooC: 'test3'
+      });
     });
 
     it('should accept 2 generic parameters on Schema', () => {
@@ -31,8 +36,38 @@ describe('Morphism', () => {
         foo: 'inputA'
       };
       morphism(schema, { inputA: 'test' });
-
       morphism(schema, [{ inputA: '' }]);
     });
+
+    it('should accept 2 generic parameters on Schema', () => {
+      interface S {
+        s1: string;
+      }
+      interface D {
+        d1: string;
+      }
+      const schema: StrictSchema<D, S> = {
+        d1: 's1'
+      };
+      morphism(schema)([{ s1: 'test' }]).shift().d1;
+      morphism(schema, { s1: 'teest' }).d1.toString();
+      morphism(schema, [{ s1: 'teest' }]).shift().d1;
+      morphism(schema, [{ s1: 'teest' }]);
+      morphism(schema, [{ s1: 'test' }]);
+      // morphism(schema,[{}])
+    });
+
+    // xit('should fail with typescript', () => {
+    //   interface S {
+    //     s1: string;
+    //   }
+    //   interface D {
+    //     d1: string;
+    //   }
+    //   const schema: StrictSchema<D, S> = {
+    //     d1: 's1'
+    //   };
+    //   morphism(schema, [{ toto: 'test' }]);
+    // });
   });
 });

src/typings.spec.ts

@@ -30,9 +30,9 @@ describe('Morphism', () => {
       interface IFoo {
         foo: string;
       }
-      const schema = { foo: 'bar' };
+      const schema: Schema<IFoo> = { foo: 'bar' };
       const source = { bar: 'value' };
-      const mapper = morphism<IFoo>(schema);
+      const mapper = morphism(schema);
 
       expect(mapper(source).foo).toEqual('value');
       expect(mapper([source][0]).foo).toEqual('value');
@@ -50,9 +50,7 @@ describe('Morphism', () => {
       const schema: StrictSchema<Destination, Source> = {
         foo: 'bar',
         bar: 'bar',
-        qux: elem => {
-          elem.bar;
-        }
+        qux: elem => elem.bar
       };
       const source = { bar: 'value' };
       // const target2 = morphism(
@@ -114,12 +112,12 @@ describe('Morphism', () => {
         foo: string;
         bar: number;
       }
-      const schema: StrictSchema<IFoo> = { foo: 'qux', bar: () => 'test' };
+      const schema: StrictSchema<IFoo> = { foo: 'qux', bar: () => 1 };
       const source = { qux: 'foo' };
       const target = morphism(schema, source);
 
       expect(target.foo).toEqual(source.qux);
-      expect(target.bar).toEqual('test');
+      expect(target.bar).toEqual(1);
     });
   });
 });