feat: dynamic generation mode (ardeois#86)

Adding a configuration option `dynamic?: boolean` that defaults to false and makes no changes to the output, but when set to true generates mock values dynamically at run time (when a mock function is called), rather than statically at build time (when a mock function is generated).

Fixes ardeois#85

Author: JimmyPaolini

.eslintignore

@@ -1,2 +1,2 @@
 dist
-node_modules
+node_modules

.gitignore

@@ -15,5 +15,5 @@ yarn-debug.log*
 yarn-error.log*
 
 # generated test file
-/tests/circular-mocks/mocks.ts
+/tests/**/mocks.ts
 

README.md

@@ -129,6 +129,10 @@ export const aUser = (overrides?: Partial<User>): User => {
 
 When disabled, underscores will be retained for type names when the case is changed. It has no effect if `typenames` is set to `keep`.
 
+### dynamicValues (`boolean`, defaultValue: `false`)
+
+When enabled, values will be generated dynamically when the mock function is called rather than statically when the mock function is generated. The values are generated consistently from a [casual seed](https://github.com/boo1ean/casual#seeding) that can be manually configured using the generated `seedMocks(seed: number)` function, as shown in [this test](https://github.com/JimmyPaolini/graphql-codegen-typescript-mock-data/blob/dynamic-mode/tests/dynamicValues/spec.ts#L13).
+
 ## Examples of usage
 
 **codegen.yml**

jest.config.js

@@ -3,5 +3,5 @@ module.exports = {
     transform: {
         '^.+\\.tsx?$': 'ts-jest',
     },
-    globalSetup: './tests/circular-mocks/create-mocks.ts',
+    globalSetup: './tests/globalSetup.ts',
 };

src/index.ts

@@ -21,6 +21,7 @@ type Options<T = TypeNode> = {
     currentType: T;
     customScalars?: ScalarMap;
     transformUnderscore: boolean;
+    dynamicValues?: boolean;
 };
 
 const convertName = (value: string, fn: (v: string) => string, transformUnderscore: boolean): string => {
@@ -102,20 +103,22 @@ const getNamedType = (opts: Options<NamedTypeNode>): string | number | boolean =
         return '';
     }
 
-    casual.seed(hashedString(opts.typeName + opts.fieldName));
+    if (!opts.dynamicValues) casual.seed(hashedString(opts.typeName + opts.fieldName));
     const name = opts.currentType.name.value;
     const casedName = createNameConverter(opts.typenamesConvention, opts.transformUnderscore)(name);
     switch (name) {
         case 'String':
-            return `'${casual.word}'`;
+            return opts.dynamicValues ? `casual.word` : `'${casual.word}'`;
         case 'Float':
-            return Math.round(casual.double(0, 10) * 100) / 100;
+            return opts.dynamicValues
+                ? `Math.round(casual.double(0, 10) * 100) / 100`
+                : Math.round(casual.double(0, 10) * 100) / 100;
         case 'ID':
-            return `'${casual.uuid}'`;
+            return opts.dynamicValues ? `casual.uuid` : `'${casual.uuid}'`;
         case 'Boolean':
-            return casual.boolean;
+            return opts.dynamicValues ? `casual.boolean` : casual.boolean;
         case 'Int':
-            return casual.integer(0, 9999);
+            return opts.dynamicValues ? `casual.integer(0, 9999)` : casual.integer(0, 9999);
         default: {
             const foundType = opts.types.find((enumType: TypeItem) => enumType.name === name);
             if (foundType) {
@@ -147,9 +150,11 @@ const getNamedType = (opts: Options<NamedTypeNode>): string | number | boolean =
                         // mapping for this particular scalar
                         if (!customScalar || !customScalar.generator) {
                             if (foundType.name === 'Date') {
-                                return `'${new Date(casual.unix_time).toISOString()}'`;
+                                return opts.dynamicValues
+                                    ? `new Date(casual.unix_time).toISOString()`
+                                    : `'${new Date(casual.unix_time).toISOString()}'`;
                             }
-                            return `'${casual.word}'`;
+                            return opts.dynamicValues ? `casual.word` : `'${casual.word}'`;
                         }
 
                         // If there is a mapping to a `casual` type, then use it and make sure
@@ -163,6 +168,11 @@ const getNamedType = (opts: Options<NamedTypeNode>): string | number | boolean =
                         const generatorArgs: unknown[] = Array.isArray(customScalar.arguments)
                             ? customScalar.arguments
                             : [customScalar.arguments];
+                        if (opts.dynamicValues) {
+                            return `casual['${customScalar.generator}']${
+                                typeof embeddedGenerator === 'function' ? `(...${JSON.stringify(generatorArgs)})` : ''
+                            }`;
+                        }
                         const value =
                             typeof embeddedGenerator === 'function'
                                 ? embeddedGenerator(...generatorArgs)
@@ -316,6 +326,7 @@ export interface TypescriptMocksPluginConfig {
     typesPrefix?: string;
     enumsPrefix?: string;
     transformUnderscore?: boolean;
+    dynamicValues?: boolean;
 }
 
 interface TypeItem {
@@ -396,6 +407,7 @@ export const plugin: PluginFunction<TypescriptMocksPluginConfig> = (schema, docu
                         currentType: node.type,
                         customScalars: config.scalars,
                         transformUnderscore,
+                        dynamicValues: config.dynamicValues,
                     });
 
                     return `        ${fieldName}: overrides && overrides.hasOwnProperty('${fieldName}') ? overrides.${fieldName}! : ${value},`;
@@ -424,6 +436,7 @@ export const plugin: PluginFunction<TypescriptMocksPluginConfig> = (schema, docu
                                       currentType: field.type,
                                       customScalars: config.scalars,
                                       transformUnderscore,
+                                      dynamicValues: config.dynamicValues,
                                   });
 
                                   return `        ${field.name.value}: overrides && overrides.hasOwnProperty('${field.name.value}') ? overrides.${field.name.value}! : ${value},`;
@@ -512,12 +525,20 @@ export const plugin: PluginFunction<TypescriptMocksPluginConfig> = (schema, docu
         enumsPrefix: config.enumsPrefix,
         transformUnderscore: transformUnderscore,
     });
-    // List of function that will generate the mock.
+    // Function that will generate the mocks.
     // We generate it after having visited because we need to distinct types from enums
     const mockFns = definitions
         .map(({ mockFn }: { mockFn: () => string }) => mockFn)
-        .filter((mockFn: () => string) => !!mockFn);
-
-    return `${typesFileImport}${mockFns.map((mockFn: () => string) => mockFn()).join('\n')}
-`;
+        .filter((mockFn: () => string) => !!mockFn)
+        .map((mockFn: () => string) => mockFn())
+        .join('\n');
+
+    let mockFile = '';
+    if (config.dynamicValues) mockFile += "import casual from 'casual';\n";
+    mockFile += typesFileImport;
+    if (config.dynamicValues) mockFile += '\ncasual.seed(0);\n';
+    mockFile += mockFns;
+    if (config.dynamicValues) mockFile += '\n\nexport const seedMocks = (seed: number) => casual.seed(seed);';
+    mockFile += '\n';
+    return mockFile;
 };

tests/__snapshots__/typescript-mock-data.spec.ts.snap

@@ -795,6 +795,83 @@ export const aQuery = (overrides?: Partial<Query>): Query => {
 "
 `;
 
+exports[`should generate dynamic values in mocks 1`] = `
+"import casual from 'casual';
+
+casual.seed(0);
+
+export const anAvatar = (overrides?: Partial<Avatar>): Avatar => {
+    return {
+        id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : casual.uuid,
+        url: overrides && overrides.hasOwnProperty('url') ? overrides.url! : casual.word,
+    };
+};
+
+export const aUser = (overrides?: Partial<User>): User => {
+    return {
+        id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : casual.uuid,
+        creationDate: overrides && overrides.hasOwnProperty('creationDate') ? overrides.creationDate! : new Date(casual.unix_time).toISOString(),
+        login: overrides && overrides.hasOwnProperty('login') ? overrides.login! : casual.word,
+        avatar: overrides && overrides.hasOwnProperty('avatar') ? overrides.avatar! : anAvatar(),
+        status: overrides && overrides.hasOwnProperty('status') ? overrides.status! : Status.Online,
+        customStatus: overrides && overrides.hasOwnProperty('customStatus') ? overrides.customStatus! : AbcStatus.HasXyzStatus,
+        scalarValue: overrides && overrides.hasOwnProperty('scalarValue') ? overrides.scalarValue! : casual.word,
+        camelCaseThing: overrides && overrides.hasOwnProperty('camelCaseThing') ? overrides.camelCaseThing! : aCamelCaseThing(),
+        unionThing: overrides && overrides.hasOwnProperty('unionThing') ? overrides.unionThing! : anAvatar(),
+        prefixedEnum: overrides && overrides.hasOwnProperty('prefixedEnum') ? overrides.prefixedEnum! : PrefixedEnum.PrefixedValue,
+    };
+};
+
+export const aWithAvatar = (overrides?: Partial<WithAvatar>): WithAvatar => {
+    return {
+        id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : casual.uuid,
+        avatar: overrides && overrides.hasOwnProperty('avatar') ? overrides.avatar! : anAvatar(),
+    };
+};
+
+export const aCamelCaseThing = (overrides?: Partial<CamelCaseThing>): CamelCaseThing => {
+    return {
+        id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : casual.uuid,
+    };
+};
+
+export const aPrefixedResponse = (overrides?: Partial<PrefixedResponse>): PrefixedResponse => {
+    return {
+        ping: overrides && overrides.hasOwnProperty('ping') ? overrides.ping! : casual.word,
+    };
+};
+
+export const anAbcType = (overrides?: Partial<AbcType>): AbcType => {
+    return {
+        abc: overrides && overrides.hasOwnProperty('abc') ? overrides.abc! : casual.word,
+    };
+};
+
+export const anUpdateUserInput = (overrides?: Partial<UpdateUserInput>): UpdateUserInput => {
+    return {
+        id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : casual.uuid,
+        login: overrides && overrides.hasOwnProperty('login') ? overrides.login! : casual.word,
+        avatar: overrides && overrides.hasOwnProperty('avatar') ? overrides.avatar! : anAvatar(),
+    };
+};
+
+export const aMutation = (overrides?: Partial<Mutation>): Mutation => {
+    return {
+        updateUser: overrides && overrides.hasOwnProperty('updateUser') ? overrides.updateUser! : aUser(),
+    };
+};
+
+export const aQuery = (overrides?: Partial<Query>): Query => {
+    return {
+        user: overrides && overrides.hasOwnProperty('user') ? overrides.user! : aUser(),
+        prefixed_query: overrides && overrides.hasOwnProperty('prefixed_query') ? overrides.prefixed_query! : aPrefixedResponse(),
+    };
+};
+
+export const seedMocks = (seed: number) => casual.seed(seed);
+"
+`;
+
 exports[`should generate mock data functions 1`] = `
 "
 export const anAvatar = (overrides?: Partial<Avatar>): Avatar => {

tests/circular-mocks/create-mocks.ts

@@ -0,0 +1,25 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`should generate dynamic values when dynamicValues is true 1`] = `
+Object {
+  "id": "99bd9d8d-79a6-474e-8f46-6cc8796ed151",
+  "obj": Object {
+    "bool": false,
+    "flt": 3.68,
+    "int": 202,
+  },
+  "str": "est",
+}
+`;
+
+exports[`should generate dynamic values when dynamicValues is true 2`] = `
+Object {
+  "id": "ec2ddf7c-d78c-4a1b-a928-ec816742cb73",
+  "obj": Object {
+    "bool": true,
+    "flt": 0.19,
+    "int": 1352,
+  },
+  "str": "similique",
+}
+`;

tests/dynamicValues/__snapshots__/spec.ts.snap

@@ -0,0 +1,15 @@
+import { buildSchema } from 'graphql';
+
+export default buildSchema(/* GraphQL */ `
+    type A {
+        id: ID!
+        str: String!
+        obj: B!
+    }
+
+    type B {
+        int: Int!
+        flt: Float!
+        bool: Boolean!
+    }
+`);

tests/dynamicValues/schema.ts

@@ -0,0 +1,26 @@
+import { anA, seedMocks } from './mocks';
+
+it('should generate dynamic values when dynamicValues is true', () => {
+    const a1 = anA();
+    expect(a1).toMatchSnapshot();
+
+    const a2 = anA();
+    expect(a2).toMatchSnapshot();
+
+    expect(a1).not.toEqual(a2);
+});
+
+it('should generate dynamic values from seed when dynamicValues is true', () => {
+    seedMocks(0);
+    const a1 = anA();
+
+    seedMocks(0);
+    const a1Copy = anA();
+
+    seedMocks(1);
+    const a2 = anA();
+
+    expect(a1).toEqual(a1Copy);
+    expect(a1).not.toEqual(a2);
+    expect(a1Copy).not.toEqual(a2);
+});

tests/dynamicValues/spec.ts

@@ -0,0 +1,11 @@
+export type A = {
+    id: string;
+    str: string;
+    obj: B;
+};
+
+export type B = {
+    int: number;
+    flt: number;
+    bool: boolean;
+};

tests/dynamicValues/types.ts

@@ -0,0 +1,18 @@
+import fs from 'fs';
+import { plugin } from '../src';
+import circularRelationshipsSchema from './terminateCircularRelationships/schema';
+import dynamicValuesSchema from './dynamicValues/schema';
+
+export default async () => {
+    const terminateCircularRelationshipsMocks = await plugin(circularRelationshipsSchema, [], {
+        typesFile: './types.ts',
+        terminateCircularRelationships: true,
+    });
+    fs.writeFileSync('./tests/terminateCircularRelationships/mocks.ts', terminateCircularRelationshipsMocks.toString());
+
+    const dynamicValuesMocks = await plugin(dynamicValuesSchema, [], {
+        typesFile: './types.ts',
+        dynamicValues: true,
+    });
+    fs.writeFileSync('./tests/dynamicValues/mocks.ts', dynamicValuesMocks.toString());
+};

tests/globalSetup.ts

@@ -0,0 +1,18 @@
+import { buildSchema } from 'graphql';
+
+export default buildSchema(/* GraphQL */ `
+    type A {
+        B: B!
+        C: C!
+    }
+    type B {
+        A: A!
+    }
+    type C {
+        aCollection: [A!]!
+    }
+    type D {
+        A: A!
+        B: B!
+    }
+`);

tests/terminateCircularRelationships/schema.ts

@@ -389,3 +389,10 @@ it('should preserve underscores if transformUnderscore is false', async () => {
     );
     expect(result).toMatchSnapshot();
 });
+
+it('should generate dynamic values in mocks', async () => {
+    const result = await plugin(testSchema, [], { dynamicValues: true });
+
+    expect(result).toBeDefined();
+    expect(result).toMatchSnapshot();
+});