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

package/src/generateResolverFiles/getImportStatementWithExpectedNamedImport.spec.ts

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

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

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

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

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

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

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