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

package/src/validateAndMergeParsedConfigs/validateAndMergeParsedConfigs.spec.ts

@@ -1,211 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

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