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

package/src/generateResolverFiles/handleGraphQLRootObjectTypeField.ts

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

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

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

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

package/src/generateResolverFiles/postProcessFiles.ts

@@ -1,287 +0,0 @@
-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;
-  }
-};