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

package/src/generateResolverFiles/handleGraphQLRootObjectTypeField.ts

@@ -0,0 +1,105 @@
+import {
+  printImportLine,
+  isMatchResolverNamePattern,
+  logger,
+  type RootObjectType,
+} from '../utils/index.js';
+import type { GraphQLTypeHandler } from './types.js';
+
+export const handleGraphQLRootObjectTypeField: GraphQLTypeHandler<
+  RootObjectType
+> = (
+  {
+    fieldFilePath,
+    isFileAlreadyOnFilesystem,
+    resolverName,
+    belongsToRootObject,
+    normalizedResolverName,
+    resolversTypeMeta,
+    moduleName,
+    relativePathFromBaseToModule,
+  },
+  {
+    result,
+    config: { resolverGeneration, emitLegacyCommonJSImports, importExtension },
+  }
+) => {
+  if (
+    (belongsToRootObject === 'Query' &&
+      !isMatchResolverNamePattern({
+        pattern: resolverGeneration.query,
+        value: normalizedResolverName.withModule,
+      }) &&
+      !isFileAlreadyOnFilesystem) ||
+    (belongsToRootObject === 'Mutation' &&
+      !isMatchResolverNamePattern({
+        pattern: resolverGeneration.mutation,
+        value: normalizedResolverName.withModule,
+      }) &&
+      !isFileAlreadyOnFilesystem) ||
+    (belongsToRootObject === 'Subscription' &&
+      !isMatchResolverNamePattern({
+        pattern: resolverGeneration.subscription,
+        value: normalizedResolverName.withModule,
+      }) &&
+      !isFileAlreadyOnFilesystem)
+  ) {
+    const resolverGenerationPattern =
+      belongsToRootObject === 'Query'
+        ? resolverGeneration.query
+        : belongsToRootObject === 'Mutation'
+        ? resolverGeneration.mutation
+        : belongsToRootObject === 'Subscription'
+        ? resolverGeneration.subscription
+        : 'Unknown';
+    logger.debug(
+      `Skipped ${belongsToRootObject} resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGenerationPattern}".`
+    );
+    return;
+  }
+
+  const suggestion = `/* Implement ${normalizedResolverName.base} resolver logic here */`;
+
+  const resolverTypeString = `NonNullable<${resolversTypeMeta.typeString}>`;
+
+  let variableStatement = `export const ${resolverName}: ${resolverTypeString} = async (_parent, _arg, _ctx) => { ${suggestion} };`;
+  if (belongsToRootObject === 'Subscription') {
+    variableStatement = `export const ${resolverName}: ${resolverTypeString} = {
+      subscribe: async (_parent, _arg, _ctx) => { ${suggestion} },
+    }`;
+  }
+
+  const resolverTypeImportDeclaration = printImportLine({
+    isTypeImport: true,
+    module: resolversTypeMeta.module,
+    moduleType: resolversTypeMeta.moduleType,
+    namedImports: [resolversTypeMeta.typeNamedImport],
+    emitLegacyCommonJSImports,
+    importExtension,
+  });
+
+  result.files[fieldFilePath] = {
+    __filetype: 'rootObjectTypeFieldResolver',
+    filesystem: {
+      type: 'virtual',
+      contentUpdated: false,
+    },
+    content: `
+        ${resolverTypeImportDeclaration}
+        ${variableStatement}`,
+    mainImportIdentifier: resolverName,
+    meta: {
+      moduleName,
+      relativePathFromBaseToModule,
+      belongsToRootObject,
+      resolverTypeImportDeclaration,
+      variableStatement,
+      resolverType: {
+        baseImport: resolversTypeMeta.typeNamedImport,
+        resolver: resolversTypeMeta.typeString,
+        final: resolverTypeString,
+      },
+      normalizedResolverName,
+    },
+  };
+};

package/src/generateResolverFiles/handleGraphQLScalarType.ts

@@ -0,0 +1,81 @@
+import {
+  printImportLine,
+  isMatchResolverNamePattern,
+  logger,
+} from '../utils/index.js';
+import type { GraphQLTypeHandler } from './types.js';
+
+const graphQLScalarType = 'GraphQLScalarType';
+
+export const handleGraphQLScalarType: GraphQLTypeHandler = (
+  {
+    fieldFilePath,
+    isFileAlreadyOnFilesystem,
+    resolverName,
+    normalizedResolverName,
+    moduleName,
+    relativePathFromBaseToModule,
+  },
+  {
+    result,
+    config: { resolverGeneration, emitLegacyCommonJSImports, importExtension },
+  }
+) => {
+  if (
+    !isMatchResolverNamePattern({
+      pattern: resolverGeneration.scalar,
+      value: normalizedResolverName.withModule,
+    }) &&
+    !isFileAlreadyOnFilesystem
+  ) {
+    logger.debug(
+      `Skipped Scalar resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.scalar}".`
+    );
+    return;
+  }
+
+  const resolverTypeImportDeclaration = printImportLine({
+    isTypeImport: false,
+    module: 'graphql',
+    moduleType: 'module',
+    namedImports: [graphQLScalarType],
+    emitLegacyCommonJSImports,
+    importExtension,
+  });
+  const variableStatement = `export const ${resolverName} = new ${graphQLScalarType}({
+    name: '${resolverName}',
+    description: '${resolverName} description',
+    serialize: (value) => {
+      /* Implement logic to turn the returned value from resolvers to a value that can be sent to clients */
+    },
+    parseValue: (value) => {
+      /* Implement logic to parse input that was sent to the server as variables */
+    },
+    parseLiteral: (ast) => {
+      /* Implement logic to parse input that was sent to the server as literal values (string, number, or boolean) */
+    },
+  });`;
+
+  result.files[fieldFilePath] = {
+    __filetype: 'scalarResolver',
+    filesystem: {
+      type: 'virtual',
+      contentUpdated: false,
+    },
+    content: `
+    ${resolverTypeImportDeclaration}
+    ${variableStatement}`,
+    mainImportIdentifier: resolverName,
+    meta: {
+      moduleName,
+      relativePathFromBaseToModule,
+      normalizedResolverName,
+      resolverTypeImportDeclaration,
+      variableStatement,
+      resolverType: {
+        baseImport: graphQLScalarType,
+        final: graphQLScalarType,
+      },
+    },
+  };
+};

package/src/generateResolverFiles/handleGraphQLUnionType.ts

@@ -0,0 +1,68 @@
+import {
+  printImportLine,
+  isMatchResolverNamePattern,
+  logger,
+} from '../utils/index.js';
+import type { GraphQLTypeHandler } from './types.js';
+
+export const handleGraphQLUnionType: GraphQLTypeHandler = (
+  {
+    fieldFilePath,
+    isFileAlreadyOnFilesystem,
+    resolverName,
+    normalizedResolverName,
+    resolversTypeMeta,
+    moduleName,
+    relativePathFromBaseToModule,
+  },
+  {
+    result,
+    config: { resolverGeneration, emitLegacyCommonJSImports, importExtension },
+  }
+) => {
+  if (
+    !isMatchResolverNamePattern({
+      pattern: resolverGeneration.union,
+      value: normalizedResolverName.withModule,
+    }) &&
+    !isFileAlreadyOnFilesystem
+  ) {
+    logger.debug(
+      `Skipped Union resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.union}".`
+    );
+    return;
+  }
+
+  const resolverTypeImportDeclaration = printImportLine({
+    isTypeImport: true,
+    module: resolversTypeMeta.module,
+    moduleType: resolversTypeMeta.moduleType,
+    namedImports: [resolversTypeMeta.typeNamedImport],
+    emitLegacyCommonJSImports,
+    importExtension,
+  });
+  const variableStatement = `export const ${resolverName}: ${resolversTypeMeta.typeString} = { /* Implement ${resolverName} union logic here */ };`;
+
+  result.files[fieldFilePath] = {
+    __filetype: 'unionResolver',
+    filesystem: {
+      type: 'virtual',
+      contentUpdated: false,
+    },
+    content: `
+    ${resolverTypeImportDeclaration}
+    ${variableStatement}`,
+    mainImportIdentifier: resolverName,
+    meta: {
+      moduleName,
+      relativePathFromBaseToModule,
+      normalizedResolverName,
+      resolverType: {
+        baseImport: resolversTypeMeta.typeNamedImport,
+        final: resolversTypeMeta.typeString,
+      },
+      resolverTypeImportDeclaration,
+      variableStatement,
+    },
+  };
+};

package/src/generateResolverFiles/index.ts

@@ -0,0 +1,2 @@
+export { generateResolverFiles } from './generateResolverFiles.js';
+export type * from './types.js';

package/src/generateResolverFiles/postProcessFiles.ts

@@ -0,0 +1,287 @@
+import type { SourceFile } from 'ts-morph';
+import * as path from 'path';
+import { cwd } from '../utils/index.js';
+import type { ResolverFile, GenerateResolverFilesContext } from './types.js';
+import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
+import {
+  type AddedPropertyAssignmentNodes,
+  addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented,
+} from './addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.js';
+import { ensureEnumTypeResolversAreGenerated } from './ensureEnumTypeResolversAreGenerated.js';
+import { getImportStatementWithExpectedNamedImport } from './getImportStatementWithExpectedNamedImport.js';
+
+/**
+ * postProcessFiles does static analysis on existing files OR to-be-generated files
+ * e.g.
+ * - Make sure correct variables are exported
+ * - Make sure object types have field resolvers if mapper type's field cannot be used as schema type's field
+ */
+export const postProcessFiles = ({
+  config: {
+    tsMorph: { project },
+    fixObjectTypeResolvers,
+  },
+  result,
+}: GenerateResolverFilesContext): void => {
+  const sourceFilesToProcess: {
+    sourceFile: SourceFile;
+    resolverFile: ResolverFile;
+  }[] = [];
+
+  // 1. Load resolver files into ts-morph project so we can run static analysis
+  Object.entries(result.files).forEach(([filePath, file]) => {
+    if (file.__filetype === 'file') {
+      return;
+    }
+
+    const existingSourceFile = project.addSourceFileAtPathIfExists(filePath);
+    if (existingSourceFile) {
+      file.filesystem = {
+        type: 'filesystem',
+        contentUpdated: false,
+      };
+      sourceFilesToProcess.push({
+        sourceFile: existingSourceFile,
+        resolverFile: file,
+      });
+      return;
+    }
+
+    // If cannot find existing source files, load files that need post-processing into sourceFilesToProcess
+    if (file.__filetype === 'objectType') {
+      const virtualSourceFile = project.createSourceFile(
+        filePath,
+        file.content
+      );
+      sourceFilesToProcess.push({
+        sourceFile: virtualSourceFile,
+        resolverFile: file,
+      });
+    }
+  });
+
+  // `addedPropertyAssignmentNodes` is used to store added property assignments in object types
+  // these property assigments are to be removed if there's no TypeScript error
+  const addedPropertyAssignmentNodes: AddedPropertyAssignmentNodes = {};
+
+  sourceFilesToProcess.forEach(({ sourceFile, resolverFile }) => {
+    const normalizedRelativePath = path.posix.relative(
+      cwd(),
+      sourceFile.getFilePath()
+    );
+
+    const { addedVariableStatement } = ensureExportedResolver(
+      sourceFile,
+      resolverFile
+    );
+
+    if (
+      resolverFile.__filetype !== 'scalarResolver' ||
+      // For scalarResolver, only add `import { GraphQLScalarType } ...` if variable statement was added.
+      // This is because user could have used custom scalar. If so, we don't want to add unnecessary import
+      (resolverFile.__filetype === 'scalarResolver' && addedVariableStatement)
+    ) {
+      ensureImportedType(sourceFile, resolverFile);
+    }
+
+    if (
+      (fixObjectTypeResolvers.object === 'smart' ||
+        fixObjectTypeResolvers.object === 'fast') &&
+      resolverFile.__filetype === 'objectType'
+    ) {
+      addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented({
+        addedPropertyAssignmentNodes,
+        sourceFile,
+        resolverFile,
+        mode: fixObjectTypeResolvers.object,
+      });
+    }
+
+    if (
+      (fixObjectTypeResolvers.enum === 'smart' ||
+        fixObjectTypeResolvers.enum === 'fast') &&
+      resolverFile.__filetype === 'enumResolver'
+    ) {
+      ensureEnumTypeResolversAreGenerated(sourceFile, resolverFile);
+    }
+
+    // Overwrite existing files with fixes
+    result.files[normalizedRelativePath] = {
+      ...resolverFile,
+      content: sourceFile.getText(),
+    };
+  });
+
+  // 3. ensure object type's added property assignments are removed if there's no related TypeScript error
+  // We do this only once at the project level instead of sourceFile level to speed up the process
+  if (fixObjectTypeResolvers.object === 'smart') {
+    project.getPreEmitDiagnostics().forEach((d) => {
+      const filename = d.getSourceFile()?.getFilePath().toString();
+      if (!filename || !addedPropertyAssignmentNodes[filename]) {
+        return;
+      }
+      const lineNumberWithError = d.getLineNumber();
+
+      // If erroring on a recently added line, do not remove as user needs to implement it
+      if (
+        lineNumberWithError &&
+        addedPropertyAssignmentNodes[filename][lineNumberWithError]
+      ) {
+        addedPropertyAssignmentNodes[filename][
+          lineNumberWithError
+        ].__toBeRemoved = false;
+      }
+    });
+    Object.values(addedPropertyAssignmentNodes).forEach((addedNodes) => {
+      Object.values(addedNodes).forEach(
+        ({ node, resolverFile, __toBeRemoved }) => {
+          if (__toBeRemoved) {
+            node.remove();
+          } else {
+            // If found a property assignment that cannot be removed i.e. incompatible types between mapper vs schema types
+            // Then we must mark the content as updated to be added to generate list
+            resolverFile.filesystem.contentUpdated = true;
+          }
+        }
+      );
+    });
+  }
+
+  // 4. Apply to result files the updated content done in step 2. and 3. above
+  sourceFilesToProcess.forEach(({ sourceFile, resolverFile }) => {
+    const normalizedRelativePath = path.posix.relative(
+      cwd(),
+      sourceFile.getFilePath()
+    );
+
+    // Overwrite existing files with fixes
+    result.files[normalizedRelativePath] = {
+      ...resolverFile,
+      content: sourceFile.getText(),
+    };
+  });
+};
+
+/**
+ * Ensure correctly named resolvers are exported
+ */
+const ensureExportedResolver = (
+  sourceFile: SourceFile,
+  resolverFile: ResolverFile
+): { addedVariableStatement: boolean } => {
+  const { variableStatement, isExported } =
+    getVariableStatementWithExpectedIdentifier(sourceFile, resolverFile);
+
+  /**
+   * If we found the variable statement replace its type with the expected resolver type string
+   *
+   * This is because we change the type of the resolver in some cases:
+   * 1. When `extend type <Object>` is used, we might change its original type to the picked version
+   *    e.g. `Book` might become `Pick<Book, 'title' | 'author'>`
+   */
+  let ensureCorrectResolverType: (() => void) | undefined = undefined;
+  if (variableStatement && resolverFile.meta.resolverType?.final) {
+    const variableDeclaration = variableStatement
+      .getDeclarationList()
+      .getDeclarations()[0];
+    const typeNode = variableDeclaration?.getTypeNode();
+
+    ensureCorrectResolverType = typeNode
+      ? () => {
+          const trimTypeString = (value: string): string =>
+            value.replace(/[\n\r\s]/g, '');
+
+          const trimmedOriginalTypeString = trimTypeString(typeNode.getText());
+          typeNode.replaceWithText(resolverFile.meta.resolverType.final);
+
+          // If the formatted type is the semantically the same but formatted differently from `resolverType.final`
+          // e.g.
+          // ```
+          // Pick<
+          //   BookResolvers,
+          //   | 'title'
+          //   | 'author'
+          // >`
+          // vs
+          // `Pick<Book, 'author' | 'title'>`
+          // ```
+          const newTypeStringVariants =
+            'otherVariants' in resolverFile.meta.resolverType
+              ? [
+                  resolverFile.meta.resolverType.final,
+                  ...resolverFile.meta.resolverType.otherVariants,
+                ]
+              : [resolverFile.meta.resolverType.final];
+          const trimmedNewTypeStringVariants =
+            newTypeStringVariants.map(trimTypeString);
+
+          if (
+            !trimmedNewTypeStringVariants.find(
+              (newText) => newText === trimmedOriginalTypeString
+            )
+          ) {
+            resolverFile.filesystem.contentUpdated = true;
+          }
+        }
+      : () => {
+          variableDeclaration.setType(resolverFile.meta.resolverType.final);
+          resolverFile.filesystem.contentUpdated = true;
+        };
+  }
+
+  // For non-scalarResolver, ensure correct type is imported
+  // For scalarResolver, we don't need to add type to the variable statement for a few reasons:
+  // - For cases when we need to create a new GraphQLScalarType, it infer the type from `new GraphQLScalarType`
+  // - For cases when there's custom user logic, it's up to the user to import the correct type or call `new GraphQLScalarType` by themselves
+  if (
+    resolverFile.__filetype !== 'scalarResolver' &&
+    ensureCorrectResolverType
+  ) {
+    ensureCorrectResolverType();
+  }
+
+  if (!variableStatement) {
+    // Did not find variable statement with expected identifier, add it to the end with a warning
+    sourceFile.addStatements(resolverFile.meta.variableStatement);
+    resolverFile.filesystem.contentUpdated = true;
+
+    return { addedVariableStatement: true };
+  } else if (variableStatement && !isExported) {
+    // If has identifier but not exported
+    // Add export keyword to statement
+    const isExpectedIdentifierExported = Boolean(
+      sourceFile
+        .getExportedDeclarations()
+        .get(resolverFile.mainImportIdentifier)
+    );
+    if (!isExpectedIdentifierExported) {
+      variableStatement.setIsExported(true);
+      resolverFile.filesystem.contentUpdated = true;
+    }
+    // else, if identifier's been exported do nothing
+    return { addedVariableStatement: false };
+  }
+
+  return { addedVariableStatement: false };
+};
+
+/**
+ * Ensure correctly imported resolves type generated by typescript-resolvers plugin
+ */
+const ensureImportedType = (
+  sourceFile: SourceFile,
+  resolverFile: ResolverFile
+): void => {
+  const { importDeclaration } = getImportStatementWithExpectedNamedImport(
+    sourceFile,
+    resolverFile
+  );
+
+  if (!importDeclaration) {
+    sourceFile.insertStatements(
+      0,
+      resolverFile.meta.resolverTypeImportDeclaration
+    );
+    resolverFile.filesystem.contentUpdated = true;
+  }
+};