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

package/src/parseTypeMappers/collectTypeMappersFromSourceFile.ts

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

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

package/src/parseTypeMappers/parseTypeMappers.ts

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

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

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

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

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

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

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

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