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

package/src/parseTypeMappers/collectTypeMappersFromSourceFile.ts

@@ -0,0 +1,197 @@
+import * as path from 'path';
+import { type SourceFile, type Identifier, SyntaxKind } from 'ts-morph';
+import {
+  normalizeRelativePath,
+  normalizeImportExtension,
+  type ImportExtension,
+} from '../utils/index.js';
+import type { TypeMappersMap } from './parseTypeMappers.js';
+
+export const collectTypeMappersFromSourceFile = (
+  {
+    typeMappersSourceFile,
+    typeMappersSuffix,
+    resolverTypesPath,
+    emitLegacyCommonJSImports,
+    importExtension,
+  }: {
+    typeMappersSourceFile: SourceFile;
+    typeMappersSuffix: string;
+    resolverTypesPath: string;
+    emitLegacyCommonJSImports: boolean;
+    importExtension?: ImportExtension;
+  },
+  result: TypeMappersMap
+): void => {
+  // Look for interfaces with exported keywords
+  typeMappersSourceFile.getInterfaces().forEach((interfaceDeclaration) => {
+    if (!interfaceDeclaration.hasExportKeyword()) {
+      return;
+    }
+
+    addTypeMapperDetailsIfValid(
+      {
+        kind: SyntaxKind.InterfaceDeclaration,
+        identifierNode: interfaceDeclaration.getNameNode(),
+        typeMappersSuffix,
+        typeMappersFilePath: typeMappersSourceFile.getFilePath(),
+        resolverTypesPath,
+        emitLegacyCommonJSImports,
+        importExtension,
+      },
+      result
+    );
+  });
+
+  // Look for exported types with exported keywords
+  typeMappersSourceFile.getTypeAliases().forEach((typeAlias) => {
+    if (!typeAlias.hasExportKeyword()) {
+      return;
+    }
+
+    const identifierNode = typeAlias.getNameNode();
+
+    addTypeMapperDetailsIfValid(
+      {
+        kind: SyntaxKind.TypeAliasDeclaration,
+        identifierNode,
+        typeMappersSuffix,
+        typeMappersFilePath: typeMappersSourceFile.getFilePath(),
+        resolverTypesPath,
+        emitLegacyCommonJSImports,
+        importExtension,
+      },
+      result
+    );
+  });
+
+  // Look for named exports e.g.
+  //   - export { something } from 'module';
+  //   - export type { something } from 'module';
+  //   - export { something, somethingelse as somethingelse2 }'
+
+  typeMappersSourceFile.getExportDeclarations().forEach((exportDeclaration) => {
+    exportDeclaration.getNamedExports().forEach((namedExport) => {
+      let identifierNode = namedExport.getNameNode();
+      const aliasNode = namedExport.getAliasNode();
+      if (aliasNode) {
+        identifierNode = aliasNode;
+      }
+
+      addTypeMapperDetailsIfValid(
+        {
+          kind: SyntaxKind.ExportSpecifier,
+          identifierNode,
+          typeMappersSuffix,
+          typeMappersFilePath: typeMappersSourceFile.getFilePath(),
+          resolverTypesPath,
+          emitLegacyCommonJSImports,
+          importExtension,
+        },
+        result
+      );
+    });
+  });
+
+  typeMappersSourceFile.getClasses().forEach((classDeclaration) => {
+    if (!classDeclaration.hasExportKeyword()) {
+      return;
+    }
+    const identifierNode = classDeclaration.getNameNode();
+    if (!identifierNode) {
+      // Anonymous class is skipped
+      return;
+    }
+
+    addTypeMapperDetailsIfValid(
+      {
+        kind: SyntaxKind.ClassDeclaration,
+        identifierNode,
+        typeMappersSuffix,
+        typeMappersFilePath: typeMappersSourceFile.getFilePath(),
+        resolverTypesPath,
+        emitLegacyCommonJSImports,
+        importExtension,
+      },
+      result
+    );
+  });
+};
+
+const addTypeMapperDetailsIfValid = (
+  {
+    kind,
+    identifierNode,
+    typeMappersSuffix,
+    typeMappersFilePath,
+    resolverTypesPath,
+    emitLegacyCommonJSImports,
+    importExtension,
+  }: {
+    kind:
+      | SyntaxKind.InterfaceDeclaration
+      | SyntaxKind.TypeAliasDeclaration
+      | SyntaxKind.ExportSpecifier
+      | SyntaxKind.ClassDeclaration;
+    identifierNode: Identifier;
+    typeMappersSuffix: string;
+    typeMappersFilePath: string;
+    resolverTypesPath: string;
+    emitLegacyCommonJSImports: boolean;
+    importExtension?: ImportExtension;
+  },
+  result: TypeMappersMap
+): void => {
+  const identifierName = identifierNode.getText();
+  if (!identifierName.endsWith(typeMappersSuffix)) {
+    return;
+  }
+
+  const [schemaType] = identifierName.split(typeMappersSuffix);
+  if (!schemaType) {
+    return;
+  }
+
+  /**
+   * We MUST use path.relative() instead of path.posix.relative() here
+   * Reason being `typeMappersFilePath` is a file system path e.g. C://Windows/Path/To/File or /Unix/path/to/file
+   * path.relative works correctly but returns inconsistent path seperator e.g. relative\\path\\windows or relative/path/unix
+   *
+   * Therefore, we need to split/join to normalise the path to posix path e.g relative/path/unix
+   */
+  const relativePath = path
+    .relative(path.dirname(resolverTypesPath), typeMappersFilePath)
+    .split(path.sep)
+    .join(path.posix.sep);
+
+  const parsedRelativePathFromResolverTypesToSourceFile =
+    path.parse(relativePath);
+  const relativeImportPathFromResolverTypesToSourceFile = normalizeRelativePath(
+    path.posix.join(
+      parsedRelativePathFromResolverTypesToSourceFile.dir,
+      parsedRelativePathFromResolverTypesToSourceFile.name
+    )
+  );
+
+  const fileExtension = normalizeImportExtension(
+    importExtension,
+    emitLegacyCommonJSImports
+  );
+  const configImportPath = `${relativeImportPathFromResolverTypesToSourceFile}${fileExtension}#${identifierName}`;
+
+  if (result[schemaType]) {
+    throw new Error(
+      `GraphQL type "${schemaType}" has duplicated "${identifierName}" mappers:\n  - ${configImportPath}\n  - ${result[schemaType].configImportPath}`
+    );
+  }
+
+  result[schemaType] = {
+    schemaType,
+    mapper: {
+      name: identifierName,
+      filename: typeMappersFilePath,
+      kind,
+    },
+    configImportPath,
+  };
+};

package/src/parseTypeMappers/index.ts

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

package/src/parseTypeMappers/parseTypeMappers.ts

@@ -0,0 +1,75 @@
+import * as path from 'path';
+import type { Project, SyntaxKind } from 'ts-morph';
+import type { ParseSourcesResult } from '../parseSources/index.js';
+import type { ImportExtension } from '../utils/index.js';
+import { collectTypeMappersFromSourceFile } from './collectTypeMappersFromSourceFile.js';
+
+export interface ParseTypeMappersParams {
+  sourceMap: ParseSourcesResult['sourceMap'];
+  resolverTypesPath: string;
+  typeMappersRelativeTargetDir: string;
+  typeMappersFileExtension: string;
+  typeMappersSuffix: string;
+  tsMorphProject: Project;
+  emitLegacyCommonJSImports: boolean;
+  importExtension: ImportExtension;
+}
+
+export interface TypeMapperDetails {
+  schemaType: string;
+  mapper: {
+    name: string;
+    filename: string; // e.g. /path/to/schema.mappers.ts
+    kind:
+      | SyntaxKind.InterfaceDeclaration
+      | SyntaxKind.TypeAliasDeclaration
+      | SyntaxKind.ExportSpecifier
+      | SyntaxKind.ClassDeclaration;
+  };
+  configImportPath: string;
+}
+
+export type TypeMappersMap = Record<string, TypeMapperDetails>;
+
+export const parseTypeMappers = ({
+  sourceMap,
+  resolverTypesPath,
+  typeMappersRelativeTargetDir,
+  typeMappersFileExtension,
+  typeMappersSuffix,
+  tsMorphProject,
+  emitLegacyCommonJSImports,
+  importExtension,
+}: ParseTypeMappersParams): TypeMappersMap => {
+  const result = Object.entries(sourceMap).reduce<TypeMappersMap>(
+    (res, [_, { sourcePath }]) => {
+      const typeMapperFilePath = path.posix.join(
+        sourcePath.dir,
+        typeMappersRelativeTargetDir,
+        `${sourcePath.name}${typeMappersFileExtension}`
+      );
+
+      const typeMappersSourceFile =
+        tsMorphProject.addSourceFileAtPathIfExists(typeMapperFilePath);
+
+      if (!typeMappersSourceFile) {
+        return res;
+      }
+
+      collectTypeMappersFromSourceFile(
+        {
+          typeMappersSourceFile,
+          typeMappersSuffix,
+          resolverTypesPath,
+          emitLegacyCommonJSImports,
+          importExtension,
+        },
+        res
+      );
+
+      return res;
+    },
+    {}
+  );
+  return result;
+};

package/src/preset.ts

@@ -0,0 +1,317 @@
+import * as path from 'path';
+import * as addPlugin from '@graphql-codegen/add';
+import * as schemaAstPlugin from '@graphql-codegen/schema-ast';
+import * as typeScriptPlugin from '@graphql-codegen/typescript';
+import { plugin as typeScriptResolversPlugin } from '@graphql-codegen/typescript-resolvers';
+import {
+  type Types,
+  createNoopProfiler,
+} from '@graphql-codegen/plugin-helpers';
+import { Project } from 'ts-morph';
+import { defineConfig as defineServerConfig } from '@eddeee888/gcg-server-config';
+import { parseSources } from './parseSources/index.js';
+import { parseGraphQLSchema } from './parseGraphQLSchema/index.js';
+import {
+  type GenerateResolverFilesContext,
+  generateResolverFiles,
+} from './generateResolverFiles/index.js';
+import { generateTypeDefsFiles } from './generateTypeDefsFiles/index.js';
+import { getGraphQLObjectTypeResolversToGenerate } from './getGraphQLObjectTypeResolversToGenerate/index.js';
+import { addVirtualTypesFileToTsMorphProject } from './addVirtualTypesFileToTsMorphProject/index.js';
+import { parseTypeMappers } from './parseTypeMappers/index.js';
+import {
+  type RawPresetConfig,
+  validatePresetConfig,
+} from './validatePresetConfig/index.js';
+import { validateAndMergeParsedConfigs } from './validateAndMergeParsedConfigs/index.js';
+import { normalizeAddConfigPath } from './normalizeAddConfigPath/index.js';
+import { logger } from './utils/index.js';
+
+export const presetName = '@eddeee888/gcg-typescript-resolver-files';
+
+export const preset: Types.OutputPreset<RawPresetConfig> = {
+  buildGeneratesSection: async ({
+    schema,
+    schemaAst,
+    presetConfig: rawPresetConfig,
+    baseOutputDir,
+    config: baseConfig,
+    profiler = createNoopProfiler(),
+  }) => {
+    if (!schemaAst) {
+      throw new Error('Missing schemaAst');
+    }
+    const sources = schemaAst.extensions.extendedSources;
+    if (!Array.isArray(sources) || sources.length === 0) {
+      throw new Error(
+        'Empty Sources. Make sure schema files are parsed correctly.'
+      );
+    }
+
+    const {
+      add,
+      resolverTypesPath: relativeResolverTypesPathFromBaseOutputDir,
+      resolverRelativeTargetDir,
+      mappersRelativeTargetDir: typeMappersRelativeTargetDir,
+      mappersFileExtension: typeMappersFileExtension,
+      mappersSuffix: typeMappersSuffix,
+      resolverMainFile,
+      resolverMainFileMode,
+      resolverGeneration,
+      typeDefsFilePath,
+      typeDefsFileMode,
+      mergeSchema,
+      moduleNamingMode,
+      scalarsModule,
+      scalarsOverrides,
+      mode,
+      whitelistedModules,
+      blacklistedModules,
+      externalResolvers,
+      typesPluginsConfig,
+      tsMorphProjectOptions,
+      fixObjectTypeResolvers,
+      emitLegacyCommonJSImports,
+      importExtension,
+    } = validatePresetConfig(rawPresetConfig, baseConfig);
+
+    const resolverTypesPath = path.posix.join(
+      baseOutputDir,
+      relativeResolverTypesPathFromBaseOutputDir
+    );
+
+    const normalizedAdd = normalizeAddConfigPath({ add, baseOutputDir });
+
+    const { sourceMap } = parseSources({
+      sources,
+      baseOutputDir,
+      moduleNamingMode,
+    });
+
+    const tsMorphProject = await profiler.run(
+      async () => new Project(tsMorphProjectOptions),
+      createProfilerRunName('Initialising ts-morph project')
+    );
+
+    const typeMappersMap = await profiler.run(
+      async () =>
+        parseTypeMappers({
+          sourceMap,
+          resolverTypesPath,
+          typeMappersRelativeTargetDir,
+          typeMappersFileExtension,
+          typeMappersSuffix,
+          tsMorphProject,
+          emitLegacyCommonJSImports,
+          importExtension,
+        }),
+      createProfilerRunName('parseTypeMappers')
+    );
+
+    const generatesSection: Types.GenerateOptions[] = [];
+
+    const parsedGraphQLSchemaMeta = await profiler.run(
+      async () =>
+        parseGraphQLSchema({
+          schemaAst,
+          sourceMap,
+          resolverTypesPath,
+          scalarsModule,
+          scalarsOverrides,
+          typeMappersMap,
+          mode,
+          baseOutputDir,
+          resolverRelativeTargetDir,
+          whitelistedModules,
+          blacklistedModules,
+        }),
+      createProfilerRunName('parseGraphQLSchema')
+    );
+
+    const mergedConfig = validateAndMergeParsedConfigs({
+      unmanagedNonScalarResolvers: externalResolvers,
+      parsedGraphQLSchemaMeta,
+    });
+
+    // typescript and typescript-resolvers plugins config
+    const resolverTypesConfig = defineServerConfig({
+      optionalResolveType: true,
+      resolversNonOptionalTypename: {
+        unionMember: true,
+        interfaceImplementingType: true,
+      },
+      namingConvention: 'keep',
+      emitLegacyCommonJSImports,
+      ...typesPluginsConfig,
+      scalars: mergedConfig.scalarTypes,
+      mappers: {
+        ...mergedConfig.typeMappers,
+        ...typesPluginsConfig.mappers,
+      },
+    });
+
+    // typesSourceFile is the virtual `types.generated.ts`
+    // This is useful when we need to do static analysis as most types come from this file
+    // e.g. comparing mappers field type vs schema object field type
+    const { typesSourceFile, meta: generatedTypesFileMeta } =
+      await profiler.run(
+        () =>
+          addVirtualTypesFileToTsMorphProject({
+            tsMorphProject,
+            schemaAst,
+            resolverTypesConfig,
+            resolverTypesPath,
+            addConfig: normalizedAdd?.[resolverTypesPath],
+          }),
+        createProfilerRunName('addVirtualTypesFileToTsMorphProject')
+      );
+
+    const graphQLObjectTypeResolversToGenerate = await profiler.run(
+      async () =>
+        fixObjectTypeResolvers.object === 'disabled'
+          ? {}
+          : getGraphQLObjectTypeResolversToGenerate({
+              mode: fixObjectTypeResolvers.object,
+              tsMorphProject,
+              typesSourceFile,
+              userDefinedSchemaObjectTypeMap:
+                mergedConfig.userDefinedSchemaTypeMap.object,
+              typeMappersMap,
+              generatedTypesFileMeta,
+            }),
+      createProfilerRunName('getGraphQLObjectTypeResolversToGenerate')
+    );
+
+    const resolverTypesFilePlugins: Types.PluginConfig[] = [
+      { typescript: {} },
+      { ['typescript-resolvers']: {} },
+    ];
+    if (normalizedAdd?.[resolverTypesPath]) {
+      resolverTypesFilePlugins.push({
+        add: normalizedAdd[resolverTypesPath],
+      });
+    }
+    const resolverTypesFile: Types.GenerateOptions = {
+      filename: resolverTypesPath,
+      pluginMap: {
+        typescript: typeScriptPlugin,
+        'typescript-resolvers': { plugin: typeScriptResolversPlugin },
+        add: addPlugin,
+      },
+      plugins: resolverTypesFilePlugins,
+      config: resolverTypesConfig,
+      schema,
+      documents: [],
+    };
+    generatesSection.push(resolverTypesFile);
+
+    // typeDefs
+    if (typeDefsFilePath) {
+      const typeDefsFiles = await profiler.run(async () => {
+        return generateTypeDefsFiles({
+          baseOutputDir,
+          typeDefsFilePath,
+          typeDefsFileMode,
+          sourceMap,
+          whitelistedModules,
+          blacklistedModules,
+        });
+      }, createProfilerRunName('generateTypeDefsFiles'));
+
+      Object.entries(typeDefsFiles).forEach(([filename, meta]) => {
+        const typeDefsFile: Types.GenerateOptions = {
+          filename: filename,
+          pluginMap: { add: addPlugin },
+          plugins: [{ add: { content: meta.content } }],
+          config: {},
+          schema,
+          documents: [],
+        };
+        generatesSection.push(typeDefsFile);
+      });
+    }
+
+    // merge schema
+    if (mergeSchema) {
+      generatesSection.push({
+        filename: path.posix.join(baseOutputDir, mergeSchema.path),
+        pluginMap: { ['schema-ast']: schemaAstPlugin },
+        plugins: [{ ['schema-ast']: {} }],
+        schema,
+        documents: [],
+        config: mergeSchema.config,
+      });
+    }
+
+    // resolver files
+    const result: GenerateResolverFilesContext['result'] = {
+      files: {},
+      externalImports: {},
+    };
+    await profiler.run(
+      async () =>
+        generateResolverFiles({
+          config: {
+            baseOutputDir,
+            resolverTypesPath,
+            resolverRelativeTargetDir,
+            resolverMainFile,
+            resolverMainFileMode,
+            resolverGeneration,
+            typeMappersMap,
+            parsedGraphQLSchemaMeta,
+            graphQLObjectTypeResolversToGenerate,
+            tsMorph: {
+              project: tsMorphProject,
+              typesSourceFile,
+            },
+            fixObjectTypeResolvers,
+            unmanagedResolvers: {
+              ...mergedConfig.unmanagedResolvers,
+            },
+            emitLegacyCommonJSImports,
+            importExtension,
+            generatedTypesFileMeta,
+          },
+          result,
+        }),
+      createProfilerRunName('generateResolverFiles')
+    );
+
+    const resultFilesArray = Object.entries(result.files);
+    const resolverFilesGenerateOptions: Types.GenerateOptions[] =
+      resultFilesArray
+        .filter(([_, file]) => {
+          // Only generate files that are:
+          // 1. `virtual` - because file doesn't exist yet
+          // 2. on `filesystem` and with `contentUpdated` - because file content has been updated, so we want to apply the changes
+          return (
+            file.filesystem.type === 'virtual' ||
+            (file.filesystem.type === 'filesystem' &&
+              file.filesystem.contentUpdated === true)
+          );
+        })
+        .map(([filename, { content }]) => {
+          return {
+            filename,
+            pluginMap: { add: addPlugin },
+            plugins: [{ add: { content } }],
+            config: {},
+            schema,
+            documents: [],
+          };
+        });
+    logger.debug(
+      `Applying changes to ${resolverFilesGenerateOptions.length}/${
+        resultFilesArray.length
+      } files. (${
+        resultFilesArray.length - resolverFilesGenerateOptions.length
+      } skipped files because they are already on filesystem and are not updated)`
+    );
+
+    return [...resolverFilesGenerateOptions, ...generatesSection];
+  },
+};
+
+const createProfilerRunName = (traceName: string): string =>
+  `[${presetName}]: ${traceName}`;

package/src/utils/cwd.ts

@@ -0,0 +1,8 @@
+import * as path from 'path';
+
+/**
+ * It is process.cwd() but normalised for all OS
+ */
+export const cwd = (): string => {
+  return process.cwd().split(path.sep).join(path.posix.sep);
+};

package/src/utils/fmt.ts

@@ -0,0 +1,16 @@
+import { presetName } from '../preset.js';
+
+/**
+ * Shared message formatter
+ */
+export const fmt = {
+  error: (input: string, type: 'Validation'): string => {
+    return `[${presetName}] \x1b[31mERROR:\x1b[0m ${type} - ${input}`;
+  },
+  warn: (input: string): string => {
+    return `[${presetName}] \x1b[33mWARN:\x1b[0m ${input}`;
+  },
+  debug: (input: string): string => {
+    return `[${presetName}] \x1b[35mDEBUG:\x1b[0m ${input}`;
+  },
+};

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+export * from './cwd.js';
+export * from './logger.js';
+export * from './fmt.js';
+export * from './parseLocationForWhitelistedModule.js';
+export * from './isNativeNamedType.js';
+export * from './isRootObjectType.js';
+export * from './isWhitelistedModule.js';
+export * from './printImportLine.js';
+export * from './normalizeRelativePath.js';
+export * from './relativeModulePath.js';
+export * from './isMatchResolverNamePattern.js';
+export * from './normalizeImportExtension.js';

package/src/utils/isMatchResolverNamePattern.ts

@@ -0,0 +1,27 @@
+import micromatch from 'micromatch';
+
+/**
+ * @description Wrapper function to return true if `value` matches on of the `pattern`s
+ */
+export const isMatchResolverNamePattern = ({
+  pattern,
+  value,
+}: {
+  pattern: string | string[];
+  value: string;
+}): boolean => {
+  const normalizedPatterns = typeof pattern === 'string' ? [pattern] : pattern;
+  const nonEmptyNormalizedPatterns = normalizedPatterns.filter(Boolean);
+
+  const matchedValues = micromatch([value], nonEmptyNormalizedPatterns, {
+    // `micromatch` mainly matches filesystems whilst we want this function
+    // to match object-like path pattern e.g.
+    // - `book.Query.books`
+    // - `book.Book`
+    // - `.BookResult` (in the case where module mode are merged i.e. `mode=merged`)
+    // so set `dot=true` to treat `.` the same as other characters
+    dot: true,
+  });
+
+  return matchedValues.length > 0;
+};

package/src/utils/isNativeNamedType.ts

@@ -0,0 +1,21 @@
+import {
+  type GraphQLNamedType,
+  isIntrospectionType,
+  isSpecifiedScalarType,
+} from 'graphql';
+
+export const isNativeNamedType = (namedType: GraphQLNamedType): boolean => {
+  // "Native" NamedType in this context means the following:
+  // 1. introspection types i.e. with `__` prefixes
+  // 2. base scalars e.g. Boolean, Int, etc.
+  // 3. Other natives (mostly base scalars) which was not defined in the schema i.e. no `astNode`
+  if (
+    isSpecifiedScalarType(namedType) ||
+    isIntrospectionType(namedType) ||
+    !namedType.astNode
+  ) {
+    return true;
+  }
+
+  return false;
+};

package/src/utils/isRootObjectType.ts

@@ -0,0 +1,8 @@
+export type RootObjectType = 'Query' | 'Mutation' | 'Subscription';
+
+export const isRootObjectType = (
+  typeName: string
+): typeName is RootObjectType =>
+  typeName === 'Query' ||
+  typeName === 'Mutation' ||
+  typeName === 'Subscription';