@eddeee888/gcg-typescript-resolver-files 0.16.0 → 0.18.0

package/src/validateAndMergeParsedConfigs/validateAndMergeParsedConfigs.spec.ts

@@ -0,0 +1,211 @@
+import { validateAndMergeParsedConfigs } from './validateAndMergeParsedConfigs';
+
+describe('validateAndMergeParsedConfigs', () => {
+  it('merges configs correctly', () => {
+    const result = validateAndMergeParsedConfigs({
+      unmanagedNonScalarResolvers: {
+        User: 'userResolvers#User as UserResolver',
+      },
+      parsedGraphQLSchemaMeta: {
+        userDefinedSchemaTypeMap: {
+          query: {},
+          mutation: {},
+          subscription: {},
+          interface: {},
+          union: {},
+          enum: {},
+          object: {
+            User: {
+              'src/schema/user': {
+                moduleName: 'user',
+                schemaType: 'User',
+                normalizedResolverName: {
+                  base: 'User',
+                  withModule: 'user.User',
+                },
+                fieldsToPick: [],
+                relativePathFromBaseToModule: ['user'],
+                relativePathToResolverTypesFile: '../types.generated.ts',
+                resolverFile: {
+                  name: 'User',
+                  path: 'user/User.ts',
+                  isOnFilesystem: false,
+                },
+                typeNamedImport: () => 'User',
+                typeString: () => 'UserResolver',
+              },
+            },
+          },
+          scalar: {
+            DateTime: {
+              moduleName: 'base',
+              schemaType: 'DateTime',
+              typeString: () => 'DateTimeResolver',
+              typeNamedImport: () => 'DateTimeResolver',
+              resolverFile: {
+                name: 'DateTime',
+                path: 'base/DateTime.ts',
+                isOnFilesystem: false,
+              },
+              relativePathToResolverTypesFile: '../types.generated.ts',
+              relativePathFromBaseToModule: ['./DateTime'],
+              normalizedResolverName: {
+                base: 'DateTime',
+                withModule: 'base.DateTime',
+              },
+            },
+          },
+        },
+        pluginsConfig: {
+          defaultTypeMappers: {
+            User: './user/schema.mappers#UserMapper',
+          },
+          defaultScalarTypesMap: {
+            DateTime: 'string',
+          },
+          scalarsModuleResolvers: {
+            DateTime: '~graphql-scalars#DateTimeResolver',
+          },
+          unmanagedScalarResolvers: {},
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      unmanagedResolvers: {
+        User: 'userResolvers#User as UserResolver',
+        DateTime: '~graphql-scalars#DateTimeResolver',
+      },
+      scalarTypes: {
+        DateTime: 'string',
+      },
+      typeMappers: {
+        User: './user/schema.mappers#UserMapper',
+      },
+      userDefinedSchemaTypeMap: {
+        query: {},
+        mutation: {},
+        subscription: {},
+        interface: {},
+        union: {},
+        enum: {},
+        object: {
+          User: {
+            'src/schema/user': {
+              moduleName: 'user',
+              schemaType: 'User',
+              normalizedResolverName: {
+                base: 'User',
+                withModule: 'user.User',
+              },
+              fieldsToPick: [],
+              relativePathFromBaseToModule: ['user'],
+              relativePathToResolverTypesFile: '../types.generated.ts',
+              resolverFile: {
+                name: 'User',
+                path: 'user/User.ts',
+                isOnFilesystem: false,
+              },
+              typeNamedImport: expect.any(Function),
+              typeString: expect.any(Function),
+            },
+          },
+        },
+        scalar: {
+          DateTime: {
+            moduleName: 'base',
+            schemaType: 'DateTime',
+            typeString: expect.any(Function),
+            typeNamedImport: expect.any(Function),
+            resolverFile: {
+              name: 'DateTime',
+              path: 'base/DateTime.ts',
+              isOnFilesystem: false,
+            },
+            relativePathToResolverTypesFile: '../types.generated.ts',
+            relativePathFromBaseToModule: ['./DateTime'],
+            normalizedResolverName: {
+              base: 'DateTime',
+              withModule: 'base.DateTime',
+            },
+          },
+        },
+      },
+    });
+  });
+
+  it('throws error if input externalResolvers is used for scalars', () => {
+    expect(() =>
+      validateAndMergeParsedConfigs({
+        unmanagedNonScalarResolvers: {
+          DateTime: '~graphql-scalars#DateTimeResolver',
+        },
+        parsedGraphQLSchemaMeta: {
+          userDefinedSchemaTypeMap: {
+            query: {},
+            mutation: {},
+            subscription: {},
+            interface: {},
+            union: {},
+            enum: {},
+            object: {
+              User: {
+                'src/schema/user': {
+                  moduleName: 'user',
+                  schemaType: 'User',
+                  normalizedResolverName: {
+                    base: 'User',
+                    withModule: 'user.User',
+                  },
+                  fieldsToPick: [],
+                  relativePathFromBaseToModule: ['user'],
+                  relativePathToResolverTypesFile: '../types.generated.ts',
+                  resolverFile: {
+                    name: 'User',
+                    path: 'user/User.ts',
+                    isOnFilesystem: false,
+                  },
+                  typeNamedImport: () => 'User',
+                  typeString: () => 'UserResolver',
+                },
+              },
+            },
+            scalar: {
+              DateTime: {
+                moduleName: 'base',
+                schemaType: 'DateTime',
+                typeString: () => 'DateTimeResolver',
+                typeNamedImport: () => 'DateTimeResolver',
+                resolverFile: {
+                  name: 'DateTime',
+                  path: 'base/DateTime.ts',
+                  isOnFilesystem: false,
+                },
+                relativePathToResolverTypesFile: '../types.generated.ts',
+                relativePathFromBaseToModule: ['./DateTime'],
+                normalizedResolverName: {
+                  base: 'DateTime',
+                  withModule: 'base.DateTime',
+                },
+              },
+            },
+          },
+          pluginsConfig: {
+            defaultTypeMappers: {
+              User: './user/schema.mappers#UserMapper',
+            },
+            defaultScalarTypesMap: {
+              DateTime: 'string',
+            },
+            scalarsModuleResolvers: {
+              DateTime: '~graphql-scalars#DateTimeResolver',
+            },
+            unmanagedScalarResolvers: {},
+          },
+        },
+      })
+    ).toThrow(
+      'Validation - Scalar "DateTime" found in presetConfig.externalResolvers. Use presetConfig.scalarsOverrides to override scalar implementation and type. Remove "DateTime" from presetConfig.externalResolvers.'
+    );
+  });
+});

package/src/validateAndMergeParsedConfigs/validateAndMergeParsedConfigs.ts

@@ -0,0 +1,92 @@
+import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema/index.js';
+import type {
+  ParsedPresetConfig,
+  ScalarsOverridesType,
+} from '../validatePresetConfig/index.js';
+import { fmt } from '../utils/index.js';
+
+interface MergedConfig {
+  userDefinedSchemaTypeMap: ParsedGraphQLSchemaMeta['userDefinedSchemaTypeMap'];
+  scalarTypes: Record<string, ScalarsOverridesType>;
+  typeMappers: Record<string, string>;
+  /**
+   * Resolvers users explicitly wants to control i.e. unmanaged by server preset so no static analysis is run on these resolvers
+   * This is set by a few options:
+   * - config.externalResolvers: for non-scalar types
+   * - config.scalarsOverrides: for scalar types
+   * - external resolvers e.g. from `graphql-scalars` module
+   **/
+  unmanagedResolvers: Record<string, string>;
+}
+
+/**
+ * validateAndMergeParsedConfigs is used to make sure all parsed configs do not incorrectly override each other.
+ * Use this to ensure there's only one way of doing something. e.g.
+ *   - scalarsOverrides must be used over externalResolvers to override scalars
+ */
+export const validateAndMergeParsedConfigs = ({
+  unmanagedNonScalarResolvers,
+  parsedGraphQLSchemaMeta: {
+    userDefinedSchemaTypeMap,
+    pluginsConfig: {
+      scalarsModuleResolvers,
+      unmanagedScalarResolvers,
+      defaultScalarTypesMap,
+      defaultTypeMappers,
+    },
+  },
+}: {
+  unmanagedNonScalarResolvers: ParsedPresetConfig['externalResolvers'];
+  parsedGraphQLSchemaMeta: ParsedGraphQLSchemaMeta;
+}): MergedConfig => {
+  Object.keys(scalarsModuleResolvers).forEach((schemaType) => {
+    if (
+      // If the scalar is defined on the filesystem, it means user wants to use their custom definition.
+      // This means we should use it, instead of importing it from scalar module
+      userDefinedSchemaTypeMap.scalar[schemaType]?.resolverFile.isOnFilesystem
+    ) {
+      delete scalarsModuleResolvers[schemaType];
+    }
+  });
+
+  // By default, codegen doesn't generate types for enums
+  // This is great for the default codegen setup but it's not great for server preset - where we need to be able to import
+  // generated resolver types to fill in content for resolver files without needing to manually set up mappers/enumValues
+  // `schemaEnumTypeMappers` is the schema mappers for enums, which can be overriden by user's provided mapper types
+  const schemaEnumTypeMappers = Object.entries(
+    userDefinedSchemaTypeMap.enum
+  ).reduce<Record<string, string>>(
+    (result, [enumTypename, { allowedValues }]) => {
+      result[enumTypename] = allowedValues.map((v) => `'${v}'`).join(' | ');
+      return result;
+    },
+    {}
+  );
+
+  Object.keys(unmanagedNonScalarResolvers).forEach((schemaType) => {
+    if (userDefinedSchemaTypeMap.scalar[schemaType]) {
+      throw new Error(
+        fmt.error(
+          `Scalar "${schemaType}" found in presetConfig.externalResolvers. Use presetConfig.scalarsOverrides to override scalar implementation and type. Remove "${schemaType}" from presetConfig.externalResolvers.`,
+          'Validation'
+        )
+      );
+    }
+  });
+
+  return {
+    userDefinedSchemaTypeMap,
+    scalarTypes: {
+      ...defaultScalarTypesMap,
+    },
+    typeMappers: {
+      ...schemaEnumTypeMappers,
+      ...defaultTypeMappers,
+    },
+    unmanagedResolvers: {
+      ...unmanagedNonScalarResolvers,
+      ...scalarsModuleResolvers,
+      ...unmanagedScalarResolvers,
+    },
+  };
+};

package/src/validatePresetConfig/index.ts

@@ -0,0 +1 @@
+export * from './validatePresetConfig.js';