feat: add composeInputWithJson method

nodkz · nodkz · commit 40039233af98 · 2020-05-10T02:23:27.000+06:00
diff --git a/README.md b/README.md
@@ -27,7 +27,7 @@ You have a sample response object `restApiResponse` which you can pass to `graph
 ```js
 // person.js
 
-import composeWithJson from 'graphql-compose-json';
+import { composeWithJson, composeInputWithJson } from 'graphql-compose-json';
 
 const restApiResponse = {
   name: 'Anakin Skywalker',
@@ -49,15 +49,18 @@ const restApiResponse = {
 };
 
 export const PersonTC = composeWithJson('Person', restApiResponse);
-export const PersonGraphQLType = PersonTC.getType();
+export const PersonGraphQLType = PersonTC.getType(); // GraphQLObjectType
+
+export const PersonITC = composeInputWithJson('PersonInput', restApiResponse);
+export const PersonGraphQLInput = PersonITC.getType(); // GraphQLInputObjectType
 ```
 
 ## Customization
 
 You can write custom field configs directly to a field of your API response object via function (see `mass` and `starships_count` field):
 
 ```js
-import composeWithJson from 'graphql-compose-json';
+import { composeWithJson } from 'graphql-compose-json';
 
 const restApiResponse = {
   name: 'Anakin Skywalker',
diff --git a/src/InputObjectParser.ts b/src/InputObjectParser.ts
@@ -0,0 +1,76 @@
+import {
+  InputTypeComposer,
+  upperFirst,
+  InputTypeComposerFieldConfigDefinition,
+  schemaComposer,
+  SchemaComposer,
+} from 'graphql-compose';
+
+type GetValueOpts = {
+  typeName?: string;
+  fieldName?: string;
+};
+
+export default class InputObjectParser {
+  static createITC(
+    name: string,
+    json: Record<string, any>,
+    opts?: { schemaComposer: SchemaComposer<any> }
+  ): InputTypeComposer<any> {
+    if (!json || typeof json !== 'object') {
+      throw new Error('You provide empty object in second arg for `createITC` method.');
+    }
+
+    const sc = opts?.schemaComposer || schemaComposer;
+
+    const tc = sc.createInputTC(name);
+    Object.keys(json).forEach((fieldName) => {
+      const fieldConfig = this.getFieldConfig(json[fieldName], { typeName: name, fieldName });
+      tc.setField(fieldName, fieldConfig);
+    });
+
+    return tc;
+  }
+
+  static getFieldConfig(
+    value: any,
+    opts?: GetValueOpts | null
+  ): InputTypeComposerFieldConfigDefinition {
+    const typeOf = typeof value;
+
+    if (typeOf === 'number') return 'Float';
+    if (typeOf === 'string') return 'String';
+    if (typeOf === 'boolean') return 'Boolean';
+
+    if (typeOf === 'object') {
+      if (value === null) return 'JSON';
+
+      if (Array.isArray(value)) {
+        if (Array.isArray(value[0])) return ['JSON'];
+
+        const val =
+          typeof value[0] === 'object' && value[0] !== null
+            ? Object.assign({}, ...value)
+            : value[0];
+
+        const args =
+          opts && opts.typeName && opts.fieldName
+            ? {
+                typeName: opts.typeName,
+                fieldName: opts.fieldName,
+              }
+            : {};
+        return [this.getFieldConfig(val, args)] as any;
+      }
+
+      if (opts && opts.typeName && opts.fieldName) {
+        return this.createITC(`${opts.typeName}_${upperFirst(opts.fieldName)}`, value);
+      }
+    }
+
+    if (typeOf === 'function') {
+      return value();
+    }
+    return 'JSON';
+  }
+}
diff --git a/src/__tests__/InputObjectParser-test.ts b/src/__tests__/InputObjectParser-test.ts
@@ -0,0 +1,137 @@
+import { InputTypeComposer } from 'graphql-compose';
+import IOP from '../InputObjectParser';
+
+describe('InputObjectParser', () => {
+  describe('getFieldConfig()', () => {
+    it('number', () => {
+      expect(IOP.getFieldConfig(6)).toBe('Float');
+      expect(IOP.getFieldConfig(77.7)).toBe('Float');
+    });
+
+    it('string', () => {
+      expect(IOP.getFieldConfig('test')).toBe('String');
+    });
+
+    it('boolean', () => {
+      expect(IOP.getFieldConfig(true)).toBe('Boolean');
+      expect(IOP.getFieldConfig(false)).toBe('Boolean');
+    });
+
+    it('null', () => {
+      expect(IOP.getFieldConfig(null)).toBe('JSON');
+    });
+
+    describe('array', () => {
+      it('of number', () => {
+        expect(IOP.getFieldConfig([1, 2, 3])).toEqual(['Float']);
+      });
+
+      it('of string', () => {
+        expect(IOP.getFieldConfig(['a', 'b', 'c'])).toEqual(['String']);
+      });
+
+      it('of boolean', () => {
+        expect(IOP.getFieldConfig([false, true])).toEqual(['Boolean']);
+      });
+
+      it('of object', () => {
+        const spy = jest.spyOn(IOP, 'createITC');
+        const valueAsArrayOfObjects = [{ a: 123 }, { a: 456 }];
+        IOP.getFieldConfig(valueAsArrayOfObjects, {
+          typeName: 'ParentTypeName',
+          fieldName: 'subDocument',
+        });
+        expect(spy).toHaveBeenCalledWith('ParentTypeName_SubDocument', { a: 456 });
+      });
+
+      it('of any', () => {
+        expect(IOP.getFieldConfig([null])).toEqual(['JSON']);
+      });
+    });
+
+    it('function', () => {
+      const valueAsFn = () => 'abracadabra';
+      const res = IOP.getFieldConfig(valueAsFn);
+      expect(res).toBe('abracadabra');
+    });
+
+    it('object', () => {
+      const spy = jest.spyOn(IOP, 'createITC');
+      const valueAsObj = { a: 123 };
+      IOP.getFieldConfig(valueAsObj, {
+        typeName: 'ParentTypeName',
+        fieldName: 'subDocument',
+      });
+      expect(spy).toHaveBeenCalledWith('ParentTypeName_SubDocument', valueAsObj);
+    });
+  });
+
+  describe('createITC()', () => {
+    it('return InputTypeComposer', () => {
+      const tc = IOP.createITC('MyType', { a: 1 });
+      expect(tc).toBeInstanceOf(InputTypeComposer);
+      expect(tc.getTypeName()).toBe('MyType');
+    });
+
+    it('creates fields', () => {
+      const tc = IOP.createITC('MyType', { a: 1, b: true });
+      expect(tc.getFieldNames()).toEqual(['a', 'b']);
+      expect(tc.getFieldTypeName('a')).toBe('Float');
+      expect(tc.getFieldTypeName('b')).toBe('Boolean');
+    });
+
+    it('match snapshot', () => {
+      const PeopleITC = IOP.createITC('PeopleInput', {
+        name: 'Luke Skywalker',
+        height: () => 'Int',
+        mass: () => 'Int',
+        hair_color: 'blond',
+        skin_color: 'fair',
+        eye_color: 'blue',
+        birth_year: '19BBY',
+        gender: 'male',
+        homeworld: {
+          name: 'Tatooine',
+          rotation_period: '23',
+          orbital_period: '304',
+          terrain: 'desert',
+          surface_water: '1',
+          population: () => 'Int',
+        },
+        films: [
+          'https://swapi.co/api/films/2/',
+          'https://swapi.co/api/films/6/',
+          'https://swapi.co/api/films/3/',
+        ],
+        created: () => 'Date',
+        edited: '2014-12-20T21:17:56.891000Z',
+      });
+
+      expect(PeopleITC.toSDL({ deep: true, omitScalars: true })).toMatchInlineSnapshot(`
+        "input PeopleInput {
+          name: String
+          height: Int
+          mass: Int
+          hair_color: String
+          skin_color: String
+          eye_color: String
+          birth_year: String
+          gender: String
+          homeworld: PeopleInput_Homeworld
+          films: [String]
+          created: Date
+          edited: String
+        }
+
+        input PeopleInput_Homeworld {
+          name: String
+          rotation_period: String
+          orbital_period: String
+          terrain: String
+          surface_water: String
+          population: Int
+        }"
+      `);
+    });
+  });
+});
diff --git a/src/__tests__/ObjectParser-test.ts b/src/__tests__/ObjectParser-test.ts
@@ -1,8 +1,6 @@
-import { graphql, ObjectTypeComposer } from 'graphql-compose';
+import { ObjectTypeComposer } from 'graphql-compose';
 import OP from '../ObjectParser';
 
-const { GraphQLFloat, GraphQLBoolean } = graphql;
-
 describe('ObjectParser', () => {
   describe('getFieldConfig()', () => {
     it('number', () => {
@@ -78,8 +76,8 @@ describe('ObjectParser', () => {
     it('creates fields', () => {
       const tc = OP.createTC('MyType', { a: 1, b: true });
       expect(tc.getFieldNames()).toEqual(['a', 'b']);
-      expect(tc.getFieldType('a')).toBe(GraphQLFloat);
-      expect(tc.getFieldType('b')).toBe(GraphQLBoolean);
+      expect(tc.getFieldTypeName('a')).toBe('Float');
+      expect(tc.getFieldTypeName('b')).toBe('Boolean');
     });
 
     it('match snapshot', () => {
@@ -109,13 +107,31 @@ describe('ObjectParser', () => {
         edited: '2014-12-20T21:17:56.891000Z',
       });
 
-      const PeopleGraphQLType = PeopleTC.getType();
-      expect(PeopleGraphQLType).toMatchSnapshot();
-      expect(PeopleGraphQLType.getFields()).toMatchSnapshot();
-
-      const homeworldSubType = PeopleTC.getFieldType('homeworld') as any;
-      expect(homeworldSubType).toMatchSnapshot();
-      expect(homeworldSubType.getFields()).toMatchSnapshot();
+      expect(PeopleTC.toSDL({ deep: true, omitScalars: true })).toMatchInlineSnapshot(`
+        "type PeopleType {
+          name: String
+          height: Int
+          mass: Int
+          hair_color: String
+          skin_color: String
+          eye_color: String
+          birth_year: String
+          gender: String
+          homeworld: PeopleType_Homeworld
+          films: [String]
+          created: Date
+          edited: String
+        }
+
+        type PeopleType_Homeworld {
+          name: String
+          rotation_period: String
+          orbital_period: String
+          terrain: String
+          surface_water: String
+          population: Int
+        }"
+      `);
     });
   });
 });
diff --git a/src/__tests__/__snapshots__/ObjectParser-test.ts.snap b/src/__tests__/__snapshots__/ObjectParser-test.ts.snap
diff --git a/src/index.ts b/src/index.ts
