Bugfix/Feature: pascalCase; Bugfix: recursive nesting (#9)

This PR is going to fix the issue with pascalCase error, initially committed by @keesvanlierop
Also, I extended that functionality to support upper case enums as well.

The other thing that was failing for me was a recursive nesting.
Check this schema
```graphql
type User {
  id: Int!
  username: String!
  tasks: [Task!]!
}

type Task {
  id: Int!
  description: String
  author: User!
  status: TaskStatus!
}
```

so, when I create a mock of a task -> user mock will be created, but then user mock will create a task mock and this will run recursively until the stack can't hold it anymore.
Overrides won't help because they come **after** the mock is created so I switched to the getters, so they won't create a nested mock if there is an override.

Author: bohdanbirdie

README.md

@@ -18,6 +18,10 @@ Defines the file path containing all GraphQL types. This file can also be genera
 
 Adds `__typename` property to mock data
 
+### enumValues (`string`, defaultValue: `pascal-case#pascalCase`)
+
+Change the case of the enums. Accept `upper-case#upperCase` or `pascal-case#pascalCase`
+
 ## Example of usage
 
 **codegen.yml**
@@ -33,6 +37,7 @@ generates:
     plugins:
       - 'graphql-codegen-typescript-mock-data':
           typesFile: '../generated-types.ts'
+          enumValues: upper-case#upperCase
 ```
 
 ## Example or generated code
@@ -49,30 +54,53 @@ type User {
   id: ID!
   login: String!
   avatar: Avatar
+  status: Status!
 }
 
 type Query {
   user: User!
 }
+
+input UpdateUserInput {
+  id: ID!
+  login: String
+  avatar: Avatar
+}
+
+enum Status {
+  ONLINE
+  OFFLINE
+}
+
+type Mutation {
+  updateUser(user: UpdateUserInput): User
+}
 ```
 
 The code generated will look like:
 
 ```typescript
 export const anAvatar = (overrides?: Partial<Avatar>): Avatar => {
   return {
-    id: '1550ff93-cd31-49b4-bc38-ef1cb68bdc38',
-    url: 'aliquid',
-    ...overrides,
+    id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : '0550ff93-dd31-49b4-8c38-ff1cb68bdc38',
+    url: overrides && overrides.hasOwnProperty('url') ? overrides.url! : 'aliquid',
+  };
+};
+
+export const aUpdateUserInput = (overrides?: Partial<UpdateUserInput>): UpdateUserInput => {
+  return {
+    id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : '1d6a9360-c92b-4660-8e5f-04155047bddc',
+    login: overrides && overrides.hasOwnProperty('login') ? overrides.login! : 'qui',
+    avatar: overrides && overrides.hasOwnProperty('avatar') ? overrides.avatar! : anAvatar(),
   };
 };
 
 export const aUser = (overrides?: Partial<User>): User => {
   return {
-    id: 'b5756f00-51a6-422a-9a7d-c13ee6a63750',
-    login: 'libero',
-    avatar: anAvatar(),
-    ...overrides,
+    id: overrides && overrides.hasOwnProperty('id') ? overrides.id! : 'a5756f00-41a6-422a-8a7d-d13ee6a63750',
+    login: overrides && overrides.hasOwnProperty('login') ? overrides.login! : 'libero',
+    avatar: overrides && overrides.hasOwnProperty('avatar') ? overrides.avatar! : anAvatar(),
+    status: overrides && overrides.hasOwnProperty('status') ? overrides.status! : Status.Online,
   };
 };
 ```

package.json

@@ -24,10 +24,11 @@
     "dependencies": {
         "@graphql-codegen/plugin-helpers": "^1.13.1",
         "casual": "^1.6.2",
-        "pascal-case": "^3.1.1"
+        "pascal-case": "^3.1.1",
+        "upper-case": "^2.0.1"
     },
     "peerDependencies": {
-        "graphql": "^14.0.0"
+        "graphql": "^14.6.0"
     },
     "devDependencies": {
         "@auto-it/conventional-commits": "^9.25.0",

src/index.ts

@@ -2,21 +2,27 @@ import { printSchema, parse, visit, ASTKindToNode, NamedTypeNode, TypeNode, Visi
 import casual from 'casual';
 import { PluginFunction } from '@graphql-codegen/plugin-helpers';
 import { pascalCase } from 'pascal-case';
+import { upperCase } from 'upper-case';
+
+type EnumValuesTypes = 'upper-case#upperCase' | 'pascal-case#pascalCase';
+
+const toMockName = (name: string) => {
+    const isVowel = name.match(/^[AEIO]/);
+    return isVowel ? `an${name}` : `a${name}`;
+};
+
+const updateTextCase = (str: string, enumValues: EnumValuesTypes) => {
+    const convert = (value: string) =>
+        enumValues === 'upper-case#upperCase' ? upperCase(value || '') : pascalCase(value || '');
 
-export function toPascalCase(str: string) {
     if (str.charAt(0) === '_') {
         return str.replace(
             /^(_*)(.*)/,
-            (_match, underscorePrefix, typeName) => `${underscorePrefix}${pascalCase(typeName || '')}`,
+            (_match, underscorePrefix, typeName) => `${underscorePrefix}${convert(typeName)}`,
         );
     }
 
-    return pascalCase(str || '');
-}
-
-const toMockName = (name: string) => {
-    const isVowel = name.match(/^[AEIO]/);
-    return isVowel ? `an${name}` : `a${name}`;
+    return convert(str);
 };
 
 const hashedString = (value: string) => {
@@ -38,6 +44,7 @@ const getNamedType = (
     typeName: string,
     fieldName: string,
     types: TypeItem[],
+    enumValues: EnumValuesTypes,
     namedType?: NamedTypeNode,
 ): string | number | boolean => {
     if (!namedType) {
@@ -66,11 +73,17 @@ const getNamedType = (
                     case 'enum': {
                         // It's an enum
                         const value = foundType.values ? foundType.values[0] : '';
-                        return `${foundType.name}.${toPascalCase(value)}`;
+                        return `${foundType.name}.${updateTextCase(value, enumValues)}`;
                     }
                     case 'union':
                         // Return the first union type node.
-                        return getNamedType(typeName, fieldName, types, foundType.types && foundType.types[0]);
+                        return getNamedType(
+                            typeName,
+                            fieldName,
+                            types,
+                            enumValues,
+                            foundType.types && foundType.types[0],
+                        );
                     default:
                         throw `foundType is unknown: ${foundType.name}: ${foundType.type}`;
                 }
@@ -84,15 +97,16 @@ const generateMockValue = (
     typeName: string,
     fieldName: string,
     types: TypeItem[],
+    enumValues: EnumValuesTypes,
     currentType: TypeNode,
 ): string | number | boolean => {
     switch (currentType.kind) {
         case 'NamedType':
-            return getNamedType(typeName, fieldName, types, currentType as NamedTypeNode);
+            return getNamedType(typeName, fieldName, types, enumValues, currentType as NamedTypeNode);
         case 'NonNullType':
-            return generateMockValue(typeName, fieldName, types, currentType.type);
+            return generateMockValue(typeName, fieldName, types, enumValues, currentType.type);
         case 'ListType': {
-            const value = generateMockValue(typeName, fieldName, types, currentType.type);
+            const value = generateMockValue(typeName, fieldName, types, enumValues, currentType.type);
             return `[${value}]`;
         }
     }
@@ -104,21 +118,21 @@ const getMockString = (typeName: string, fields: string, addTypename = false) =>
 export const ${toMockName(typeName)} = (overrides?: Partial<${typeName}>): ${typeName} => {
     return {${typename}
 ${fields}
-        ...overrides
     };
 };`;
 };
 
 export interface TypescriptMocksPluginConfig {
     typesFile?: string;
+    enumValues?: EnumValuesTypes;
     addTypename?: boolean;
 }
 
 interface TypeItem {
     name: string;
     type: string;
     values?: string[];
-    types?: ReadonlyArray<NamedTypeNode>;
+    types?: readonly NamedTypeNode[];
 }
 
 type VisitorType = { [K in keyof ASTKindToNode]?: VisitFn<ASTKindToNode[keyof ASTKindToNode], ASTKindToNode[K]> };
@@ -129,6 +143,8 @@ type VisitorType = { [K in keyof ASTKindToNode]?: VisitFn<ASTKindToNode[keyof AS
 export const plugin: PluginFunction<TypescriptMocksPluginConfig> = (schema, documents, config) => {
     const printedSchema = printSchema(schema); // Returns a string representation of the schema
     const astNode = parse(printedSchema); // Transforms the string into ASTNode
+
+    const enumValues = config.enumValues || 'pascal-case#pascalCase';
     // List of types that are enums
     const types: TypeItem[] = [];
     const visitor: VisitorType = {
@@ -158,9 +174,9 @@ export const plugin: PluginFunction<TypescriptMocksPluginConfig> = (schema, docu
             return {
                 name: fieldName,
                 mockFn: (typeName: string) => {
-                    const value = generateMockValue(typeName, fieldName, types, node.type);
+                    const value = generateMockValue(typeName, fieldName, types, enumValues, node.type);
 
-                    return `        ${fieldName}: ${value},`;
+                    return `        ${fieldName}: overrides && overrides.hasOwnProperty('${fieldName}') ? overrides.${fieldName}! : ${value},`;
                 },
             };
         },
@@ -173,9 +189,15 @@ export const plugin: PluginFunction<TypescriptMocksPluginConfig> = (schema, docu
                     const mockFields = node.fields
                         ? node.fields
                               .map((field) => {
-                                  const value = generateMockValue(fieldName, field.name.value, types, field.type);
-
-                                  return `        ${field.name.value}: ${value},`;
+                                  const value = generateMockValue(
+                                      fieldName,
+                                      field.name.value,
+                                      types,
+                                      enumValues,
+                                      field.type,
+                                  );
+
+                                  return `        ${field.name.value}: overrides && overrides.hasOwnProperty('${field.name.value}') ? overrides.${field.name.value}! : ${value},`;
                               })
                               .join('\n')
                         : '';