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

package/src/generateResolverFiles/types.ts

@@ -0,0 +1,203 @@
+import type { SourceFile, Project } from 'ts-morph';
+import type * as typeScriptResolversPlugin from '@graphql-codegen/typescript-resolvers';
+import type { GraphQLObjectTypeResolversToGenerate } from '../getGraphQLObjectTypeResolversToGenerate/index.js';
+import type { TypeMappersMap } from '../parseTypeMappers/index.js';
+import type {
+  ImportExtension,
+  ImportLineMeta,
+  RootObjectType,
+} from '../utils/index.js';
+import type { ParsedPresetConfig } from '../validatePresetConfig/index.js';
+import type { NormalizedResolverName } from '../parseGraphQLSchema/index.js';
+import type { ParsedGraphQLSchemaMeta } from '../parseGraphQLSchema/index.js';
+
+export type GeneratedTypesFileMeta = {
+  generatedResolverTypes: NonNullable<
+    Awaited<ReturnType<typeof typeScriptResolversPlugin.plugin>>['meta']
+  >['generatedResolverTypes'];
+};
+
+interface BaseVirtualFile {
+  __filetype: string;
+  filesystem: {
+    type: 'virtual' | 'filesystem';
+    contentUpdated: boolean;
+  };
+  content: string;
+  mainImportIdentifier: string;
+}
+
+export interface StandardFile extends BaseVirtualFile {
+  __filetype: 'file';
+}
+
+export interface InterfacelResolverFile extends BaseVirtualFile {
+  __filetype: 'interfaceResolver';
+  meta: {
+    moduleName: string;
+    relativePathFromBaseToModule: string[];
+    resolverTypeImportDeclaration: string;
+    variableStatement: string;
+    resolverType: {
+      baseImport: string; // e.g. `NodeResolvers`
+      final: string;
+    };
+    normalizedResolverName: NormalizedResolverName;
+  };
+}
+
+export interface UnionResolverFile extends BaseVirtualFile {
+  __filetype: 'unionResolver';
+  meta: {
+    moduleName: string;
+    relativePathFromBaseToModule: string[];
+    resolverTypeImportDeclaration: string;
+    variableStatement: string;
+    resolverType: {
+      baseImport: string; // e.g. `NodeResolvers`
+      final: string;
+    };
+    normalizedResolverName: NormalizedResolverName;
+  };
+}
+
+export interface ScalarResolverFile extends BaseVirtualFile {
+  __filetype: 'scalarResolver';
+  meta: {
+    moduleName: string;
+    relativePathFromBaseToModule: string[];
+    resolverTypeImportDeclaration: string;
+    variableStatement: string;
+    resolverType: {
+      baseImport: string; // e.g. `NodeResolvers`
+      final: string;
+    };
+    normalizedResolverName: NormalizedResolverName;
+  };
+}
+
+export interface EnumResolverFile extends BaseVirtualFile {
+  __filetype: 'enumResolver';
+  meta: {
+    moduleName: string;
+    relativePathFromBaseToModule: string[];
+    resolverTypeImportDeclaration: string;
+    variableStatement: string;
+    resolverType: {
+      baseImport: string; // e.g. `NodeResolvers`
+      final: string;
+    };
+    normalizedResolverName: NormalizedResolverName;
+    allowedValues: string[];
+  };
+}
+
+export interface RootObjectTypeFieldResolverFile extends BaseVirtualFile {
+  __filetype: 'rootObjectTypeFieldResolver';
+  meta: {
+    moduleName: string;
+    relativePathFromBaseToModule: string[];
+    belongsToRootObject: RootObjectType;
+    resolverTypeImportDeclaration: string;
+    variableStatement: string;
+    resolverType: {
+      baseImport: string; // e.g. `QueryResolvers`
+      resolver: string; // e.g. `QueryResolvers['user']`
+      final: string; // e.g. `NonNullable<<QueryResolvers['user']>`
+    };
+    normalizedResolverName: NormalizedResolverName;
+  };
+}
+
+export interface ObjectTypeFile extends BaseVirtualFile {
+  __filetype: 'objectType';
+  meta: {
+    moduleName: string;
+    relativePathFromBaseToModule: string[];
+    resolverTypeImportDeclaration: string;
+    variableStatement: string;
+    resolverType: {
+      baseImport: string; // e.g. `UserResolvers`
+      final: string; // e.g. `UserResolvers`, `Pick<UserResolvers, 'id'|'name'>`
+      otherVariants: string[]; // e.g. `Pick<UserResolvers, |'id'|'name'>`
+    };
+    normalizedResolverName: NormalizedResolverName;
+    resolversToGenerate?: GraphQLObjectTypeResolversToGenerate[number];
+  };
+}
+
+export type ResolverFile =
+  | RootObjectTypeFieldResolverFile
+  | ObjectTypeFile
+  | InterfacelResolverFile
+  | UnionResolverFile
+  | ScalarResolverFile
+  | EnumResolverFile;
+
+export interface GenerateResolverFilesContext {
+  config: {
+    baseOutputDir: string;
+    resolverTypesPath: string;
+    resolverRelativeTargetDir: string;
+    resolverMainFile: string;
+    resolverMainFileMode: ParsedPresetConfig['resolverMainFileMode'];
+    resolverGeneration: ParsedPresetConfig['resolverGeneration'];
+    unmanagedResolvers: Record<string, string>;
+    tsMorph: {
+      project: Project;
+      typesSourceFile: SourceFile;
+    };
+    typeMappersMap: TypeMappersMap;
+    parsedGraphQLSchemaMeta: ParsedGraphQLSchemaMeta;
+    graphQLObjectTypeResolversToGenerate: GraphQLObjectTypeResolversToGenerate;
+    fixObjectTypeResolvers: ParsedPresetConfig['fixObjectTypeResolvers'];
+    emitLegacyCommonJSImports: boolean;
+    importExtension: ImportExtension;
+    generatedTypesFileMeta: GeneratedTypesFileMeta;
+  };
+  result: {
+    files: Record<string, StandardFile | ResolverFile>;
+    externalImports: Record<
+      string,
+      {
+        moduleName: string;
+        relativePathFromBaseToModule: string[];
+        importLineMeta: ImportLineMeta;
+        identifierUsages: {
+          identifierName: string;
+          normalizedResolverName: string;
+        }[];
+      }
+    >;
+  };
+}
+
+export interface GraphQLTypeHandlerParams<BelongsToRootObject = null> {
+  moduleName: string;
+  relativePathFromBaseToModule: string[];
+  fieldFilePath: string;
+  resolverName: string;
+  isFileAlreadyOnFilesystem: boolean;
+  belongsToRootObject: BelongsToRootObject;
+  normalizedResolverName: NormalizedResolverName;
+  resolversTypeMeta: {
+    // typeNamedImport: name of the type to be imported from `module`.
+    // If it's a root object type field, this is the root type (e.g. Query, Mutation, Subscription).
+    // Otherwise, it's the object type e.g. User, Profile, etc.
+    typeNamedImport: string;
+    // path to typescript-resolvers file
+    module: ImportLineMeta['module'];
+    moduleType: ImportLineMeta['moduleType'];
+    // typeString: valid type specified for a field or object type
+    typeString: string;
+  };
+  generatedTypesFileMeta: GeneratedTypesFileMeta;
+}
+
+export type GraphQLTypeHandler<
+  BelongsToRootObject = null,
+  ExtraParams = Record<string, unknown>
+> = (
+  params: GraphQLTypeHandlerParams<BelongsToRootObject> & ExtraParams,
+  ctx: GenerateResolverFilesContext
+) => void;

package/src/generateResolverFiles/visitNamedType.ts

@@ -0,0 +1,66 @@
+import type {
+  GraphQLTypeHandler,
+  GenerateResolverFilesContext,
+} from './types.js';
+import { addExternalResolverImport } from './addExternalResolverImport.js';
+import type { ResolverDetails } from '../parseGraphQLSchema/index.js';
+
+export const visitNamedType = <T = null>(
+  {
+    moduleName,
+    relativePathFromBaseToModule,
+    normalizedResolverName,
+    resolverFile,
+    relativePathToResolverTypesFile,
+    typeNamedImport,
+    typeString,
+    belongsToRootObject,
+    visitor,
+  }: ResolverDetails & {
+    belongsToRootObject: T;
+    visitor: GraphQLTypeHandler<T>;
+  },
+  ctx: GenerateResolverFilesContext
+): void => {
+  const unmanagedResolversImportSyntax =
+    ctx.config.unmanagedResolvers[normalizedResolverName.base];
+  if (unmanagedResolversImportSyntax) {
+    addExternalResolverImport(
+      {
+        moduleName,
+        relativePathFromBaseToModule,
+        normalizedResolverName: normalizedResolverName.base,
+        configImportSyntax: unmanagedResolversImportSyntax,
+      },
+      ctx
+    );
+
+    return;
+  }
+
+  if (ctx.result.files[resolverFile.path]) {
+    throw new Error(
+      `Unexpected duplication in field filename. Type: ${resolverFile.name}, file: ${resolverFile.path}`
+    );
+  }
+
+  visitor(
+    {
+      belongsToRootObject,
+      fieldFilePath: resolverFile.path,
+      isFileAlreadyOnFilesystem: resolverFile.isOnFilesystem,
+      moduleName,
+      normalizedResolverName,
+      relativePathFromBaseToModule,
+      resolverName: resolverFile.name,
+      resolversTypeMeta: {
+        module: relativePathToResolverTypesFile,
+        moduleType: 'file',
+        typeNamedImport: typeNamedImport(ctx.config.generatedTypesFileMeta),
+        typeString: typeString(ctx.config.generatedTypesFileMeta),
+      },
+      generatedTypesFileMeta: ctx.config.generatedTypesFileMeta,
+    },
+    ctx
+  );
+};

package/src/generateTypeDefsFiles/generateTypeDefsContent.ts

@@ -0,0 +1,15 @@
+import { mergeTypeDefs } from '@graphql-tools/merge';
+
+interface GenerateTypeDefsContentParams {
+  mergedSDL: string;
+}
+
+export const generateTypeDefsContent = ({
+  mergedSDL,
+}: GenerateTypeDefsContentParams): string => {
+  const documentNode = mergeTypeDefs(mergedSDL, { noLocation: true });
+  const documentNodeString = JSON.stringify(documentNode);
+
+  return `import type { DocumentNode } from 'graphql';
+  export const typeDefs = ${documentNodeString} as unknown as DocumentNode`;
+};

package/src/generateTypeDefsFiles/generateTypeDefsFiles.ts

@@ -0,0 +1,100 @@
+import * as path from 'path';
+import type { StandardFile } from '../generateResolverFiles/index.js';
+import type { ParseSourcesResult } from '../parseSources/index.js';
+import { cwd, isWhitelistedModule } from '../utils/index.js';
+import type { TypeDefsFileMode } from '../validatePresetConfig/index.js';
+import { generateTypeDefsContent } from './generateTypeDefsContent.js';
+
+interface GenerateTypeDefsFilesParams {
+  baseOutputDir: string;
+  typeDefsFilePath: string;
+  typeDefsFileMode: TypeDefsFileMode;
+  sourceMap: ParseSourcesResult['sourceMap'];
+  whitelistedModules: string[];
+  blacklistedModules: string[];
+}
+
+export const generateTypeDefsFiles = ({
+  baseOutputDir,
+  typeDefsFilePath,
+  typeDefsFileMode,
+  sourceMap,
+  blacklistedModules,
+  whitelistedModules,
+}: GenerateTypeDefsFilesParams): Record<string, StandardFile> => {
+  const filesContent: Record<string, string> = {};
+  Object.values(sourceMap).forEach(({ moduleName, source, sourcePath }) => {
+    const isWhitelisted = isWhitelistedModule({
+      moduleName,
+      whitelistedModules,
+      blacklistedModules,
+    });
+
+    if (typeDefsFileMode === 'merged') {
+      appendSDLToFile({
+        filesContent,
+        filePath: path.posix.join(baseOutputDir, typeDefsFilePath),
+        rawSDL: source.rawSDL,
+      });
+      return;
+    }
+
+    if (isWhitelisted && typeDefsFileMode === 'mergedWhitelisted') {
+      appendSDLToFile({
+        filesContent,
+        filePath: path.posix.join(baseOutputDir, typeDefsFilePath),
+        rawSDL: source.rawSDL,
+      });
+      return;
+    }
+
+    if (isWhitelisted && typeDefsFileMode === 'modules') {
+      // sourcePath.dir is absolute which does not work well to use as filenames for Windows
+      // example of cases where it does not work:
+      //   - when `prettier` is run in afterAllFileWrite hooks with absolute Windows path
+      const relativeSourcePathDir = path.posix.relative(cwd(), sourcePath.dir);
+      appendSDLToFile({
+        filesContent,
+        filePath: path.posix.join(relativeSourcePathDir, typeDefsFilePath),
+        rawSDL: source.rawSDL,
+      });
+      return;
+    }
+  });
+
+  const result: Record<string, StandardFile> = {};
+  Object.entries(filesContent).forEach(([filePath, content]) => {
+    result[filePath] = {
+      __filetype: 'file',
+      // TODO: this is virtual so it will always re-generate
+      // In the future, if no schema file changes, then we don't need to re-generate this file
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      content: generateTypeDefsContent({ mergedSDL: content }),
+      mainImportIdentifier: 'typeDefs',
+    };
+  });
+
+  return result;
+};
+
+const appendSDLToFile = ({
+  rawSDL,
+  filePath,
+  filesContent,
+}: {
+  rawSDL: string | undefined;
+  filePath: string;
+  filesContent: Record<string, string>;
+}): void => {
+  if (!rawSDL) {
+    return;
+  }
+
+  if (!filesContent[filePath]) {
+    filesContent[filePath] = '';
+  }
+  filesContent[filePath] += `${rawSDL}\n`;
+};

package/src/generateTypeDefsFiles/index.ts

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