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

package/src/generateResolverFiles/addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.ts

@@ -1,144 +0,0 @@
-import { type PropertyAssignment, type SourceFile, SyntaxKind } from 'ts-morph';
-import type { ObjectTypeFile } from './types.js';
-import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
-
-export type AddedPropertyAssignmentNodes = Record<
-  string, // SourceFile's filename
-  Record<
-    number, // Line number
-    {
-      node: PropertyAssignment;
-      resolverFile: ObjectTypeFile;
-      __toBeRemoved: boolean;
-    }
-  >
->;
-
-/**
- * Ensure objectTypeResolver files have all the resolvers due to mismatched types
- */
-export const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented = ({
-  addedPropertyAssignmentNodes,
-  sourceFile,
-  resolverFile,
-  mode,
-}: {
-  addedPropertyAssignmentNodes: AddedPropertyAssignmentNodes;
-  sourceFile: SourceFile;
-  resolverFile: ObjectTypeFile;
-  mode: 'smart' | 'fast';
-}): void => {
-  const sourceFilePath = sourceFile.getFilePath().toString();
-  addedPropertyAssignmentNodes[sourceFilePath] =
-    addedPropertyAssignmentNodes[sourceFilePath] || {};
-
-  const resolversToGenerate = resolverFile.meta.resolversToGenerate || {};
-  if (!Object.keys(resolversToGenerate).length) {
-    return;
-  }
-
-  const { variableStatement } = getVariableStatementWithExpectedIdentifier(
-    sourceFile,
-    resolverFile
-  );
-
-  if (!variableStatement) {
-    throw new Error(
-      'Missing variableStatement in addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.'
-    );
-  }
-
-  // 1. Check to see which generated to-be-generated resolvers are implemented
-  const resolversData: Record<
-    string,
-    {
-      resolverName: string;
-      resolverDeclaration: string;
-      implemented?: true;
-    }
-  > = { ...resolversToGenerate };
-
-  /**
-   * PropertyAssignment
-   * ```
-   * const name = () => {};
-   * const OutputType = {
-   *   id: () => {},
-   *   name: name,
-   * }
-   * ```
-   */
-  variableStatement
-    .getDescendantsOfKind(SyntaxKind.PropertyAssignment)
-    .forEach((propertyAssignment) => {
-      const resolverName = propertyAssignment.getName();
-      if (resolversData[resolverName]) {
-        resolversData[resolverName].implemented = true;
-      }
-    });
-
-  /**
-   * MethodDeclaration
-   * ```
-   * const OutputType = {
-   *   id(){},
-   * }
-   * ```
-   */
-  variableStatement
-    .getDescendantsOfKind(SyntaxKind.MethodDeclaration)
-    .forEach((methodDeclaration) => {
-      const resolverName = methodDeclaration.getName();
-      if (resolversData[resolverName]) {
-        resolversData[resolverName].implemented = true;
-      }
-    });
-
-  /**
-   * ShorthandPropertyAssignment example:
-   * ```
-   * const id = () => {};
-   * const OutputType = {
-   *   id,
-   * }
-   * ```
-   */
-  variableStatement
-    .getDescendantsOfKind(SyntaxKind.ShorthandPropertyAssignment)
-    .forEach((propertyAssignment) => {
-      const resolverName = propertyAssignment.getName();
-      if (resolversData[resolverName]) {
-        resolversData[resolverName].implemented = true;
-      }
-    });
-
-  // 2. Add missing resolver properties if they haven't been implemented
-  Object.values(resolversData).forEach(
-    ({ resolverName, resolverDeclaration, implemented }) => {
-      if (implemented) {
-        return;
-      }
-
-      const addedNode = variableStatement
-        .getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)[0]
-        .addPropertyAssignment({
-          name: resolverName,
-          initializer: resolverDeclaration,
-        });
-
-      if (mode === 'fast') {
-        resolverFile.filesystem.contentUpdated = true;
-      }
-
-      addedPropertyAssignmentNodes[sourceFilePath][
-        addedNode.getStartLineNumber()
-      ] = {
-        node: addedNode,
-        resolverFile,
-        // When mode is "smart", we use TS compiler for typechecking, and it'd remove the node if there is no compilation error. Therefore, `__toBeRemoved: true`
-        // When mode is "fast", we already check whether the the type is assignable, so no need to remove the node.
-        __toBeRemoved: mode === 'fast' ? false : true,
-      };
-    }
-  );
-};

package/src/generateResolverFiles/addResolverMainFiles.ts

@@ -1,343 +0,0 @@
-import * as path from 'path';
-import {
-  isRootObjectType,
-  printImportLine,
-  relativeModulePath,
-  type RootObjectType,
-} from '../utils/index.js';
-import type { GenerateResolverFilesContext } from './types.js';
-
-interface FileDetails {
-  importLines: string[];
-  queryFields: ObjectFieldMapping[];
-  mutationFields: ObjectFieldMapping[];
-  subscriptionFields: ObjectFieldMapping[];
-  objectTypes: ObjectTypesMap;
-}
-const createDefaultFileDetails = (): FileDetails => ({
-  importLines: [],
-  queryFields: [],
-  mutationFields: [],
-  subscriptionFields: [],
-  objectTypes: {},
-});
-
-/**
- * addResolverMainFiles
- *
- * @description Function to create resolver main file/s (default: resolvers.generated.ts)
- * If resolverMainFileMode=merged, only one file is generated
- * If resolverMainFileMode=modules, one file is generated for each module
- * If no resolvers are created or imported, do not generate a file.
- */
-export const addResolverMainFiles = ({
-  config: {
-    baseOutputDir,
-    resolverTypesPath,
-    resolverMainFile,
-    resolverMainFileMode,
-    emitLegacyCommonJSImports,
-    importExtension,
-    generatedTypesFileMeta: { generatedResolverTypes },
-  },
-  result,
-}: GenerateResolverFilesContext): void => {
-  const baseIdentifierUsage = countBaseIdentifiersUsage(result.files);
-
-  const resolverMainFiles = Object.entries(result.files).reduce<
-    Record<string, FileDetails>
-  >((res, [filepath, file]) => {
-    if (file.__filetype === 'file') {
-      return res;
-    }
-
-    const { meta } = file;
-
-    // If resolverMainFileMode === 'modules', generate main resolver files into modules, otherwise, do it at baseOutputDir
-    const resolverMainFilename =
-      resolverMainFileMode === 'modules'
-        ? path.posix.join(
-            baseOutputDir,
-            ...meta.relativePathFromBaseToModule,
-            resolverMainFile
-          )
-        : path.posix.join(baseOutputDir, resolverMainFile);
-
-    const outputDir = path.dirname(resolverMainFilename);
-
-    if (!res[resolverMainFilename]) {
-      res[resolverMainFilename] = createDefaultFileDetails();
-    }
-
-    const baseIdentifierName = makeNormalizedResolverNameVariableCompatible(
-      file.meta.normalizedResolverName.base
-    );
-    const identifierName =
-      baseIdentifierUsage[baseIdentifierName] > 1
-        ? makeNormalizedResolverNameVariableCompatible(
-            file.meta.normalizedResolverName.withModule
-          )
-        : baseIdentifierName;
-
-    const fieldMapping: ObjectFieldMapping = {
-      propertyName: file.mainImportIdentifier,
-      identifierName,
-    };
-
-    // Non Root Object fields that was generated
-    if (
-      file.__filetype === 'objectType' ||
-      file.__filetype === 'interfaceResolver' ||
-      file.__filetype === 'unionResolver' ||
-      file.__filetype === 'scalarResolver' ||
-      file.__filetype === 'enumResolver'
-    ) {
-      res[resolverMainFilename].importLines.push(
-        printImportLine({
-          isTypeImport: false,
-          module: relativeModulePath(outputDir, filepath),
-          moduleType: 'file',
-          namedImports: [fieldMapping],
-          emitLegacyCommonJSImports,
-          importExtension,
-        })
-      );
-
-      pushToObjectTypes({
-        objectTypes: res[resolverMainFilename].objectTypes,
-        property: file.mainImportIdentifier,
-        value: identifierName,
-      });
-
-      return res;
-    }
-
-    // Root object fields
-    res[resolverMainFilename].importLines.push(
-      printImportLine({
-        isTypeImport: false,
-        module: relativeModulePath(outputDir, filepath),
-        moduleType: 'file',
-        namedImports: [fieldMapping],
-        emitLegacyCommonJSImports,
-        importExtension,
-      })
-    );
-
-    const rootObjectMap: Record<RootObjectType, () => void> = {
-      Query: () => res[resolverMainFilename].queryFields.push(fieldMapping),
-      Mutation: () =>
-        res[resolverMainFilename].mutationFields.push(fieldMapping),
-      Subscription: () =>
-        res[resolverMainFilename].subscriptionFields.push(fieldMapping),
-    };
-    rootObjectMap[file.meta.belongsToRootObject]();
-
-    return res;
-  }, {});
-
-  Object.entries(result.externalImports).reduce((res, [module, meta]) => {
-    // If resolverMainFileMode === 'modules', generate main resolver files into modules, otherwise, do it at baseOutputDir
-    const resolverMainFilename =
-      resolverMainFileMode === 'modules'
-        ? path.posix.join(
-            baseOutputDir,
-            ...meta.relativePathFromBaseToModule,
-            resolverMainFile
-          )
-        : path.posix.join(baseOutputDir, resolverMainFile);
-
-    if (!res[resolverMainFilename]) {
-      res[resolverMainFilename] = createDefaultFileDetails();
-    }
-
-    res[resolverMainFilename].importLines.push(
-      printImportLine({
-        isTypeImport: false,
-        module,
-        moduleType: 'preserve',
-        namedImports: meta.importLineMeta.namedImports,
-        defaultImport: meta.importLineMeta.defaultImport,
-        emitLegacyCommonJSImports,
-        importExtension,
-      })
-    );
-
-    meta.identifierUsages.forEach((usage) => {
-      const resolverNameParts = usage.normalizedResolverName.split('.');
-
-      // Only 1 part, this is a GraphQL ObjectType
-      if (resolverNameParts.length === 1) {
-        pushToObjectTypes({
-          objectTypes: res[resolverMainFilename].objectTypes,
-          property: resolverNameParts[0],
-          value: usage.identifierName,
-        });
-        return;
-      }
-
-      // 2+ parts, treat as 2 parts. This is a GraphQL ObjectType with field e.g. Query.me, Mutation.updateUser
-      const [rootObjectType, field] = resolverNameParts;
-      if (!isRootObjectType(rootObjectType)) {
-        throw new Error(`Unexpected root object type found: ${rootObjectType}`);
-      }
-      const fieldMapping: ObjectFieldMapping = {
-        identifierName: usage.identifierName,
-        propertyName: field,
-      };
-      const rootObjectMap: Record<RootObjectType, () => void> = {
-        Query: () => res[resolverMainFilename].queryFields.push(fieldMapping),
-        Mutation: () =>
-          res[resolverMainFilename].mutationFields.push(fieldMapping),
-        Subscription: () =>
-          res[resolverMainFilename].subscriptionFields.push(fieldMapping),
-      };
-      rootObjectMap[rootObjectType]();
-    });
-
-    return res;
-  }, resolverMainFiles);
-
-  const resolversIdentifier = 'resolvers';
-  const resolversTypeName = generatedResolverTypes.resolversMap.name;
-
-  Object.entries(resolverMainFiles).forEach(([resolverMainFilename, file]) => {
-    const outputDir = path.dirname(resolverMainFilename);
-    const relativePathToResolverTypes = relativeModulePath(
-      outputDir,
-      resolverTypesPath
-    );
-
-    const queries =
-      file.queryFields.length > 0
-        ? `Query: { ${file.queryFields.map(printObjectMapping).join(',')} },`
-        : '';
-    const mutations =
-      file.mutationFields.length > 0
-        ? `Mutation: { ${file.mutationFields
-            .map(printObjectMapping)
-            .join(',')} },`
-        : '';
-    const suscriptions =
-      file.subscriptionFields.length > 0
-        ? `Subscription: { ${file.subscriptionFields
-            .map(printObjectMapping)
-            .join(',')} },`
-        : '';
-
-    result.files[resolverMainFilename] = {
-      __filetype: 'file',
-      // TODO: type='virtual' means we will generate these main files every run.
-      // Consider checking if these files are already on the filesystem, and whether the content has changed before generating?
-      filesystem: {
-        type: 'virtual',
-        contentUpdated: false,
-      },
-      mainImportIdentifier: resolversIdentifier,
-      content: `/* This file was automatically generated. DO NOT UPDATE MANUALLY. */
-    ${printImportLine({
-      isTypeImport: true,
-      module: relativePathToResolverTypes,
-      moduleType: 'file',
-      namedImports: [resolversTypeName],
-      emitLegacyCommonJSImports,
-      importExtension,
-    })}
-    ${file.importLines.join('\n')}
-    export const ${resolversIdentifier}: ${resolversTypeName} = {
-      ${queries}
-      ${mutations}
-      ${suscriptions}
-      ${printObjectTypes(file.objectTypes)}
-    }`,
-    };
-  });
-};
-
-interface ObjectFieldMapping {
-  propertyName: string;
-  identifierName: string;
-}
-const printObjectMapping = ({
-  propertyName,
-  identifierName,
-}: ObjectFieldMapping): string => `${propertyName}: ${identifierName}`;
-
-type ObjectTypesMap = Record<string, string[]>;
-const pushToObjectTypes = ({
-  objectTypes,
-  property,
-  value,
-}: {
-  objectTypes: ObjectTypesMap;
-  property: string;
-  value: string;
-}): void => {
-  if (!objectTypes[property]) {
-    objectTypes[property] = [];
-  }
-
-  objectTypes[property].push(value);
-};
-
-const printObjectTypes = (objectTypes: ObjectTypesMap): string => {
-  return Object.entries(objectTypes)
-    .map(([property, values]) => {
-      if (values.length === 1) {
-        return `${property}: ${values[0]}`;
-      }
-
-      const spreadedValueString = values
-        .map((value) => `...${value}`)
-        .join(',');
-      return `${property}: { ${spreadedValueString} }`;
-    })
-    .join(',\n');
-};
-
-/**
- * countBaseIdentifiersUsage
- *
- * function to count how many of the same identifier is used across all files
- */
-const countBaseIdentifiersUsage = (
-  files: GenerateResolverFilesContext['result']['files']
-): Record<string, number> => {
-  return Object.entries(files).reduce<Record<string, number>>(
-    (res, [_filepath, file]) => {
-      if (file.__filetype === 'file') {
-        return res;
-      }
-
-      const identifier = makeNormalizedResolverNameVariableCompatible(
-        file.meta.normalizedResolverName.base
-      );
-
-      if (!res[identifier]) {
-        res[identifier] = 0;
-      }
-
-      res[identifier]++;
-
-      return res;
-    },
-    {}
-  );
-};
-
-/**
- * makeNormalizedResolverNameVariableCompatible
- * @description Function to replace `-` and `.` in a string with underscore to be used as a variable name
- *
- * Note: this is to make sure the resolver name is a valid variable name because we use it in resolvers.generated.ts
- * However, this naive implementation means there could be a duplicated variable name if a mix of kebab-case and snake_case is used.
- * e.g. `user-by-account-name` and `user_by_account_name` will both be normalized to `user_by_account_name`
- *
- * If users report this issue. We can try another approach.
- * I'm banking my slim hope in humanity that no codebase is so chaotic that it uses both kebab-case and snake_case.
- */
-const makeNormalizedResolverNameVariableCompatible = (
-  identifier: string
-): string => {
-  return identifier.replace(/[-.]/g, '_');
-};

package/src/generateResolverFiles/ensureEnumTypeResolversAreGenerated.ts

@@ -1,51 +0,0 @@
-import { SyntaxKind, type SourceFile } from 'ts-morph';
-import type { EnumResolverFile } from './types.js';
-import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
-
-export const ensureEnumTypeResolversAreGenerated = (
-  sourceFile: SourceFile,
-  resolverFile: EnumResolverFile
-): void => {
-  const { variableStatement } = getVariableStatementWithExpectedIdentifier(
-    sourceFile,
-    resolverFile
-  );
-
-  if (!variableStatement) {
-    throw new Error(
-      'Missing variableStatement in ensureEnumTypeResolversAreGenerated.'
-    );
-  }
-
-  const allowedValuesMap = resolverFile.meta.allowedValues.reduce<
-    Record<string, { implemented: boolean }>
-  >((res, allowedValue) => {
-    res[allowedValue] = { implemented: false };
-    return res;
-  }, {});
-
-  // Mark allowed value as implemented if found
-  variableStatement
-    .getDescendantsOfKind(SyntaxKind.PropertyAssignment)
-    .forEach((propertyAssignment) => {
-      const propertyName = propertyAssignment.getName();
-      if (allowedValuesMap[propertyName]) {
-        allowedValuesMap[propertyName].implemented = true;
-      }
-    });
-
-  // Add unimplemented allowed values
-  Object.entries(allowedValuesMap).forEach(
-    ([allowedValue, { implemented }]) => {
-      if (!implemented) {
-        variableStatement
-          .getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)[0]
-          .addPropertyAssignment({
-            name: allowedValue,
-            initializer: `'${allowedValue}'`,
-          });
-        resolverFile.filesystem.contentUpdated = true;
-      }
-    }
-  );
-};

package/src/generateResolverFiles/generateResolverFiles.ts

@@ -1,148 +0,0 @@
-import { addResolverMainFiles } from './addResolverMainFiles.js';
-import { postProcessFiles } from './postProcessFiles.js';
-import { handleGraphQLRootObjectTypeField } from './handleGraphQLRootObjectTypeField.js';
-import { handleGraphQLObjectType } from './handleGraphQLObjectType.js';
-import { handleGraphQLUnionType } from './handleGraphQLUnionType.js';
-import { handleGraphQLScalarType } from './handleGraphQLScalarType.js';
-import { handleGraphQLInterfaceType } from './handleGraphQLInterfaceType.js';
-import { handleGraphQLEnumType } from './handleGraphQLEnumType.js';
-import { visitNamedType } from './visitNamedType.js';
-import type { GenerateResolverFilesContext } from './types.js';
-
-export const generateResolverFiles = (
-  ctx: GenerateResolverFilesContext
-): void => {
-  // Query
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.query
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: 'Query',
-        visitor: handleGraphQLRootObjectTypeField,
-      },
-      ctx
-    );
-  });
-
-  // Mutation
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.mutation
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: 'Mutation',
-        visitor: handleGraphQLRootObjectTypeField,
-      },
-      ctx
-    );
-  });
-
-  // Subscription
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.subscription
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: 'Subscription',
-        visitor: handleGraphQLRootObjectTypeField,
-      },
-      ctx
-    );
-  });
-
-  // Object
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.object
-  ).forEach((objectsByModules) => {
-    Object.values(objectsByModules).forEach((details) => {
-      visitNamedType(
-        {
-          ...details,
-          belongsToRootObject: null,
-          visitor: (baseParams, prev_ctx) =>
-            handleGraphQLObjectType(
-              {
-                ...baseParams,
-                fieldsToPick: details.fieldsToPick,
-              },
-              prev_ctx
-            ),
-        },
-        ctx
-      );
-    });
-  });
-
-  // Scalar
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.scalar
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: null,
-        visitor: handleGraphQLScalarType,
-      },
-      ctx
-    );
-  });
-
-  // Interface
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.interface
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: null,
-        visitor: handleGraphQLInterfaceType,
-      },
-      ctx
-    );
-  });
-
-  // Union
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.union
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: null,
-        visitor: handleGraphQLUnionType,
-      },
-      ctx
-    );
-  });
-
-  // Enum
-  Object.values(
-    ctx.config.parsedGraphQLSchemaMeta.userDefinedSchemaTypeMap.enum
-  ).forEach((details) => {
-    visitNamedType(
-      {
-        ...details,
-        belongsToRootObject: null,
-        visitor: (baseParams, prev_ctx) =>
-          handleGraphQLEnumType(
-            {
-              ...baseParams,
-              allowedValues: details.allowedValues,
-            },
-            prev_ctx
-          ),
-      },
-      ctx
-    );
-  });
-
-  // Post process generated files (could be existing files or files to be generated)
-  postProcessFiles(ctx);
-
-  // Put all resolvers into barrel file/s (or main file/s)
-  addResolverMainFiles(ctx);
-};