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

package/src/generateResolverFiles/getImportStatementWithExpectedNamedImport.spec.ts

@@ -0,0 +1,127 @@
+import { Project } from 'ts-morph';
+import { getImportStatementWithExpectedNamedImport } from './getImportStatementWithExpectedNamedImport.js';
+
+describe('getImportStatementWithExpectedNamedImport', () => {
+  it('returns import statement if found for objectType files', () => {
+    const project = new Project();
+    const sourceFile = project.createSourceFile(
+      '/pathto/User.ts',
+      `
+      import { UserResolvers } from '../types.generated.ts';
+      export const User: UserResolvers = {
+        id: ({ id }) => id,
+      }
+      `
+    );
+
+    const result = getImportStatementWithExpectedNamedImport(sourceFile, {
+      __filetype: 'objectType',
+      content: '',
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      mainImportIdentifier: 'User',
+      meta: {
+        moduleName: 'user',
+        relativePathFromBaseToModule: ['user'],
+        resolverTypeImportDeclaration: '',
+        variableStatement: '',
+        resolverType: {
+          baseImport: 'UserResolvers',
+          final: 'UserResolvers',
+          otherVariants: [],
+        },
+        normalizedResolverName: {
+          base: 'User',
+          withModule: 'user.User',
+        },
+      },
+    });
+
+    expect(result.importDeclaration?.getText()).toBe(
+      `import { UserResolvers } from '../types.generated.ts';`
+    );
+  });
+
+  it('returns import statement if found for rootObjectTypeFieldResolver files', () => {
+    const project = new Project();
+    const sourceFile = project.createSourceFile(
+      '/pathto/Query/me.ts',
+      `
+      import { QueryResolvers } from '../types.generated.ts';
+      export const me: QueryResolvers['me'] = () => {};
+      `
+    );
+
+    const result = getImportStatementWithExpectedNamedImport(sourceFile, {
+      __filetype: 'rootObjectTypeFieldResolver',
+      content: '',
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      mainImportIdentifier: 'user',
+      meta: {
+        belongsToRootObject: 'Query',
+        moduleName: 'user',
+        normalizedResolverName: {
+          base: 'Query.user',
+          withModule: 'user.Query.user',
+        },
+        relativePathFromBaseToModule: ['user'],
+        resolverType: {
+          baseImport: 'QueryResolvers',
+          resolver: "QueryResolvers['me']",
+          final: "NonNullable<QueryResolvers['me']>",
+        },
+        resolverTypeImportDeclaration: '',
+        variableStatement: '',
+      },
+    });
+
+    expect(result.importDeclaration?.getText()).toBe(
+      `import { QueryResolvers } from '../types.generated.ts';`
+    );
+  });
+
+  it('returns import statement if found for interfaceResolver files', () => {
+    const project = new Project();
+    const sourceFile = project.createSourceFile(
+      '/pathto/User.ts',
+      `
+      import { NodeResolvers } from '../types.generated.ts';
+      export const Node: NodeResolvers = {
+      }
+      `
+    );
+
+    const result = getImportStatementWithExpectedNamedImport(sourceFile, {
+      __filetype: 'interfaceResolver',
+      content: '',
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      mainImportIdentifier: 'user',
+      meta: {
+        moduleName: 'user',
+        normalizedResolverName: {
+          base: 'Query.user',
+          withModule: 'user.Query.user',
+        },
+        relativePathFromBaseToModule: ['user'],
+        resolverType: {
+          baseImport: 'NodeResolvers',
+          final: 'NodeResolvers',
+        },
+        resolverTypeImportDeclaration: '',
+        variableStatement: '',
+      },
+    });
+
+    expect(result.importDeclaration?.getText()).toBe(
+      `import { NodeResolvers } from '../types.generated.ts';`
+    );
+  });
+});

package/src/generateResolverFiles/getImportStatementWithExpectedNamedImport.ts

@@ -0,0 +1,25 @@
+import type { ImportDeclaration, SourceFile } from 'ts-morph';
+import type { ResolverFile } from './types.js';
+
+export const getImportStatementWithExpectedNamedImport = (
+  sourceFile: SourceFile,
+  resolverFile: ResolverFile
+): {
+  importDeclaration: ImportDeclaration | undefined;
+} => {
+  const importDeclaration = sourceFile.getImportDeclaration((declaration) => {
+    let foundNamedImport = false;
+    declaration.getNamedImports().forEach((namedImport) => {
+      if (
+        namedImport.getName() === resolverFile.meta.resolverType?.baseImport
+      ) {
+        foundNamedImport = true;
+      }
+    });
+    return foundNamedImport;
+  });
+
+  return {
+    importDeclaration,
+  };
+};

package/src/generateResolverFiles/getVariableStatementWithExpectedIdentifier.spec.ts

@@ -0,0 +1,147 @@
+import { Project } from 'ts-morph';
+import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
+
+describe('getVariableStatementWithExpectedIdentifier()', () => {
+  it('gets VariableStatement node and isExported=true if found', () => {
+    const project = new Project();
+    const sourceFile = project.createSourceFile(
+      '/pathto/User.ts',
+      `
+      import {} from '../types.generated.ts';
+
+      const DontLookAtThisNode = {};
+
+      export const User: UserResolvers = {
+        id: ({ id }) => id,
+      }
+
+      const DontLookAtThisNodeEither = {};
+      `
+    );
+    const result = getVariableStatementWithExpectedIdentifier(sourceFile, {
+      __filetype: 'objectType',
+      content: '',
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      mainImportIdentifier: 'User',
+      meta: {
+        moduleName: 'user',
+        relativePathFromBaseToModule: ['user'],
+        variableStatement: '',
+        resolverTypeImportDeclaration: '',
+        resolverType: {
+          baseImport: 'UserResolvers',
+          final: 'UserResolvers',
+          otherVariants: [],
+        },
+        normalizedResolverName: {
+          base: 'User',
+          withModule: 'user.User',
+        },
+      },
+    });
+
+    expect(result.isExported).toBe(true);
+    expect(result.variableStatement?.getText()).toMatchInlineSnapshot(`
+      "export const User: UserResolvers = {
+              id: ({ id }) => id,
+            }"
+    `);
+  });
+
+  it('returns variableStatement=undefined and isExported=false if NOT found', () => {
+    const project = new Project();
+    const sourceFile = project.createSourceFile(
+      '/pathto/User.ts',
+      `
+      import {} from '../types.generated.ts';
+
+      const DontLookAtThisNode = {};
+
+      export const Userssss: UserResolvers = {
+        id: ({ id }) => id,
+      }
+
+      const DontLookAtThisNodeEither = {};
+      `
+    );
+    const result = getVariableStatementWithExpectedIdentifier(sourceFile, {
+      __filetype: 'objectType',
+      content: '',
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      mainImportIdentifier: 'User',
+      meta: {
+        moduleName: 'user',
+        relativePathFromBaseToModule: ['user'],
+        variableStatement: '',
+        resolverTypeImportDeclaration: '',
+        resolverType: {
+          baseImport: 'UserResolvers',
+          final: 'UserResolvers',
+          otherVariants: [],
+        },
+        normalizedResolverName: {
+          base: 'User',
+          withModule: 'user.User',
+        },
+      },
+    });
+
+    expect(result.isExported).toBe(false);
+    expect(result.variableStatement).toBeUndefined();
+  });
+
+  it('returns variableStatement=undefined and isExported=true if found but not exported', () => {
+    const project = new Project();
+    const sourceFile = project.createSourceFile(
+      '/pathto/User.ts',
+      `
+      import {} from '../types.generated.ts';
+
+      const DontLookAtThisNode = {};
+
+      const User: UserResolvers = {
+        id: ({ id }) => id,
+      }
+
+      const DontLookAtThisNodeEither = {};
+      `
+    );
+    const result = getVariableStatementWithExpectedIdentifier(sourceFile, {
+      __filetype: 'objectType',
+      content: '',
+      filesystem: {
+        type: 'virtual',
+        contentUpdated: false,
+      },
+      mainImportIdentifier: 'User',
+      meta: {
+        moduleName: 'user',
+        relativePathFromBaseToModule: ['user'],
+        variableStatement: '',
+        resolverTypeImportDeclaration: '',
+        resolverType: {
+          baseImport: 'UserResolvers',
+          final: 'UserResolvers',
+          otherVariants: [],
+        },
+        normalizedResolverName: {
+          base: 'User',
+          withModule: 'user.User',
+        },
+      },
+    });
+
+    expect(result.isExported).toBe(false);
+    expect(result.variableStatement?.getText()).toMatchInlineSnapshot(`
+      "const User: UserResolvers = {
+              id: ({ id }) => id,
+            }"
+    `);
+  });
+});

package/src/generateResolverFiles/getVariableStatementWithExpectedIdentifier.ts

@@ -0,0 +1,34 @@
+import type { SourceFile, VariableStatement } from 'ts-morph';
+import type { ResolverFile } from './types.js';
+
+export const getVariableStatementWithExpectedIdentifier = (
+  sourceFile: SourceFile,
+  resolverFile: ResolverFile
+): {
+  variableStatement: VariableStatement | undefined;
+  isExported: boolean;
+} => {
+  let isExported = false;
+
+  const variableStatementWithExpectedIdentifier =
+    sourceFile.getVariableStatement((statement) => {
+      let hasExpectedIdentifier = false;
+      statement
+        .getDeclarationList()
+        .getDeclarations()
+        .forEach((declarationNode) => {
+          if (declarationNode.getName() === resolverFile.mainImportIdentifier) {
+            hasExpectedIdentifier = true;
+            if (statement.isExported()) {
+              isExported = true;
+            }
+          }
+        });
+      return hasExpectedIdentifier;
+    });
+
+  return {
+    variableStatement: variableStatementWithExpectedIdentifier,
+    isExported,
+  };
+};

package/src/generateResolverFiles/handleGraphQLEnumType.ts

@@ -0,0 +1,100 @@
+import {
+  isMatchResolverNamePattern,
+  logger,
+  printImportLine,
+} from '../utils/index.js';
+import type { GraphQLTypeHandler } from './types.js';
+
+export const handleGraphQLEnumType: GraphQLTypeHandler<
+  null,
+  { allowedValues: string[] }
+> = (
+  {
+    fieldFilePath,
+    relativePathFromBaseToModule,
+    resolverName,
+    isFileAlreadyOnFilesystem,
+    normalizedResolverName,
+    resolversTypeMeta,
+    moduleName,
+    allowedValues,
+  },
+  {
+    result,
+    config: {
+      typeMappersMap,
+      resolverGeneration,
+      emitLegacyCommonJSImports,
+      importExtension,
+    },
+  }
+) => {
+  const matchedPatternToGenerate = isMatchResolverNamePattern({
+    pattern: resolverGeneration.enum,
+    value: normalizedResolverName.withModule,
+  });
+  const mapperDetails = typeMappersMap[normalizedResolverName.base];
+
+  if (
+    !matchedPatternToGenerate &&
+    !mapperDetails &&
+    !isFileAlreadyOnFilesystem
+  ) {
+    logger.debug(
+      `Skipped Enum resolver generation: "${normalizedResolverName.withModule}". Pattern: "${resolverGeneration.enum}".`
+    );
+    return;
+  }
+
+  const forcedGenerationWarning = (() => {
+    if (!matchedPatternToGenerate && mapperDetails) {
+      logger.debug(
+        `Enum resolver generation was NOT skipped because there is a associated mapper: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.enum}". Mapper: ${mapperDetails.mapper.name}`
+      );
+      return `/*
+    * Note: This enum file is generated because "${mapperDetails.mapper.name}" is declared. This is to ensure runtime safety.
+    * If you want to skip this file generation, remove the mapper or update the pattern in the \`resolverGeneration.object\` config.
+    */\n`;
+    }
+    return '';
+  })();
+
+  const resolverTypeImportDeclaration = printImportLine({
+    isTypeImport: true,
+    module: resolversTypeMeta.module,
+    moduleType: resolversTypeMeta.moduleType,
+    namedImports: [resolversTypeMeta.typeNamedImport],
+    emitLegacyCommonJSImports,
+    importExtension,
+  });
+
+  const variableStatement = `${forcedGenerationWarning}export const ${resolverName}: ${
+    resolversTypeMeta.typeString
+  } = {
+    ${allowedValues.map((value) => `${value}: '${value}'`).join(',\n')}
+  }`;
+
+  result.files[fieldFilePath] = {
+    __filetype: 'enumResolver',
+    filesystem: {
+      type: 'virtual',
+      contentUpdated: false,
+    },
+    content: `
+    ${resolverTypeImportDeclaration}
+    ${variableStatement}`,
+    mainImportIdentifier: resolverName,
+    meta: {
+      moduleName,
+      relativePathFromBaseToModule,
+      resolverTypeImportDeclaration,
+      variableStatement,
+      resolverType: {
+        baseImport: resolversTypeMeta.typeNamedImport,
+        final: resolversTypeMeta.typeString,
+      },
+      normalizedResolverName,
+      allowedValues,
+    },
+  };
+};

package/src/generateResolverFiles/handleGraphQLInterfaceType.ts

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

package/src/generateResolverFiles/handleGraphQLObjectType.ts

@@ -0,0 +1,171 @@
+import type { GraphQLTypeHandler } from './types.js';
+import {
+  printImportLine,
+  isMatchResolverNamePattern,
+  logger,
+} from '../utils/index.js';
+
+export const handleGraphQLObjectType: GraphQLTypeHandler<
+  null,
+  {
+    fieldsToPick?: string[];
+  }
+> = (
+  {
+    fieldFilePath,
+    resolverName,
+    isFileAlreadyOnFilesystem,
+    normalizedResolverName,
+    resolversTypeMeta,
+    moduleName,
+    relativePathFromBaseToModule,
+    fieldsToPick = [], // If fieldsToPick.length === 0, it means the current object handles all resolvers
+    generatedTypesFileMeta,
+  },
+  {
+    result,
+    config: {
+      resolverGeneration,
+      typeMappersMap,
+      graphQLObjectTypeResolversToGenerate,
+      emitLegacyCommonJSImports,
+      importExtension,
+    },
+  }
+) => {
+  const matchedPatternToGenerate = isMatchResolverNamePattern({
+    pattern: resolverGeneration.object,
+    value: normalizedResolverName.withModule,
+  });
+  const mapperDetails = typeMappersMap[normalizedResolverName.base];
+
+  if (
+    !matchedPatternToGenerate &&
+    !mapperDetails &&
+    !isFileAlreadyOnFilesystem
+  ) {
+    logger.debug(
+      `Skipped Object resolver generation: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.object}".`
+    );
+    return;
+  }
+
+  const forcedGenerationWarning = (() => {
+    if (!matchedPatternToGenerate && mapperDetails) {
+      logger.debug(
+        `Object resolver generation was NOT skipped because there is a associated mapper: "${normalizedResolverName.withModule}". "Pattern: ${resolverGeneration.object}". Mapper: ${mapperDetails.mapper.name}`
+      );
+      return `/*
+    * Note: This object type is generated because "${mapperDetails.mapper.name}" is declared. This is to ensure runtime safety.
+    *
+    * When a mapper is used, it is possible to hit runtime errors in some scenarios:
+    * - given a field name, the schema type's field type does not match mapper's field type
+    * - or a schema type's field does not exist in the mapper's fields
+    *
+    * If you want to skip this file generation, remove the mapper or update the pattern in the \`resolverGeneration.object\` config.
+    */\n`;
+    }
+    return '';
+  })();
+
+  const hasFieldsToPick = fieldsToPick.length > 0;
+
+  // __isTypeOf is required to resolve abstract types, should user chooses this approach.
+  // TODO: Run static analysis to enforce only one __isTypeOf per Object type, so users cannot accidentally implement/override it across modules
+  if (
+    hasFieldsToPick &&
+    generatedTypesFileMeta.generatedResolverTypes.userDefined[
+      normalizedResolverName.base
+    ].hasIsTypeOf
+  ) {
+    fieldsToPick.push('__isTypeOf');
+  }
+
+  if (
+    hasFieldsToPick &&
+    generatedTypesFileMeta.generatedResolverTypes.userDefined[
+      normalizedResolverName.base
+    ].federation?.hasResolveReference
+  ) {
+    fieldsToPick.push('__resolveReference');
+  }
+
+  // - `typeString` contains the resolver type
+  //   If there's fieldsToPick, we must only pick said fields from the original resolver type
+  // - `otherTypeStringVariants` contains other types that are the same as `typeString` but formatted differently
+  //   This is used to check if the resolver type is the same when running static analysis
+  //   We want to use string comparison instead of true AST check because it's a lot faster and simpler
+  const { typeString, otherTypeStringVariants } = ((): {
+    typeString: string;
+    otherTypeStringVariants: string[];
+  } => {
+    if (hasFieldsToPick) {
+      return {
+        typeString: `Pick<${resolversTypeMeta.typeString}, ${fieldsToPick
+          .map((fieldName) => `'${fieldName}'`)
+          .join('|')}>`,
+        otherTypeStringVariants: [
+          `Pick<${resolversTypeMeta.typeString}, |${fieldsToPick
+            .map((fieldName) => `'${fieldName}'`)
+            .join('|')}>`,
+        ],
+      };
+    }
+
+    return {
+      typeString: resolversTypeMeta.typeString,
+      otherTypeStringVariants: [],
+    };
+  })();
+
+  // Array of all resolvers that may need type checking
+  // If there's fieldsToPick, we must only generate said fields
+  const allResolversToGenerate =
+    graphQLObjectTypeResolversToGenerate[resolverName];
+  const resolversToGenerate = hasFieldsToPick
+    ? fieldsToPick.reduce<typeof allResolversToGenerate>((res, fieldToPick) => {
+        if (allResolversToGenerate && allResolversToGenerate[fieldToPick]) {
+          res[fieldToPick] = allResolversToGenerate[fieldToPick];
+        }
+        return res;
+      }, {})
+    : allResolversToGenerate;
+
+  const variableStatement = `${forcedGenerationWarning}export const ${resolverName}: ${typeString} = {
+    /* Implement ${resolverName} resolver logic here */
+  };`;
+
+  const resolverTypeImportDeclaration = printImportLine({
+    isTypeImport: true,
+    module: resolversTypeMeta.module,
+    moduleType: resolversTypeMeta.moduleType,
+    namedImports: [resolversTypeMeta.typeNamedImport],
+    emitLegacyCommonJSImports,
+    importExtension,
+  });
+
+  result.files[fieldFilePath] = {
+    __filetype: 'objectType',
+    filesystem: {
+      type: 'virtual',
+      contentUpdated: false,
+    },
+    content: `
+    ${resolverTypeImportDeclaration}
+    ${variableStatement}`,
+    mainImportIdentifier: resolverName,
+    meta: {
+      moduleName,
+      relativePathFromBaseToModule,
+      normalizedResolverName,
+      resolverTypeImportDeclaration,
+      variableStatement,
+      resolverType: {
+        baseImport: resolversTypeMeta.typeNamedImport,
+        final: typeString,
+        otherVariants: otherTypeStringVariants,
+      },
+      resolversToGenerate,
+    },
+  };
+};