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

package/src/generateResolverFiles/addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.ts

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

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

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

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