@eddeee888/gcg-typescript-resolver-files 0.18.4 → 0.19.0

package/dist/generateResolverFiles/addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.d.ts

@@ -1,4 +1,4 @@
-import { type PropertyAssignment, type SourceFile } from 'ts-morph';
+import { type PropertyAssignment, type SourceFile, type VariableStatement } from 'ts-morph';
 import type { ObjectTypeFile } from './types.js';
 export type AddedPropertyAssignmentNodes = Record<string, // SourceFile's filename
 Record<number, // Line number
@@ -10,9 +10,10 @@ Record<number, // Line number
 /**
  * Ensure objectTypeResolver files have all the resolvers due to mismatched types
  */
-export declare const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented: ({ addedPropertyAssignmentNodes, sourceFile, resolverFile, mode, }: {
+export declare const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented: ({ addedPropertyAssignmentNodes, sourceFile, variableStatement, resolverFile, mode, }: {
     addedPropertyAssignmentNodes: AddedPropertyAssignmentNodes;
     sourceFile: SourceFile;
+    variableStatement: VariableStatement | undefined;
     resolverFile: ObjectTypeFile;
     mode: "smart" | "fast";
 }) => void;

package/dist/generateResolverFiles/addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented.js

@@ -1,9 +1,8 @@
-import { SyntaxKind } from 'ts-morph';
-import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
+import { SyntaxKind, } from 'ts-morph';
 /**
  * Ensure objectTypeResolver files have all the resolvers due to mismatched types
  */
-export const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented = ({ addedPropertyAssignmentNodes, sourceFile, resolverFile, mode, }) => {
+export const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented = ({ addedPropertyAssignmentNodes, sourceFile, variableStatement, resolverFile, mode, }) => {
     const sourceFilePath = sourceFile.getFilePath().toString();
     addedPropertyAssignmentNodes[sourceFilePath] =
         addedPropertyAssignmentNodes[sourceFilePath] || {};
@@ -11,71 +10,41 @@ export const addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented = ({
     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 = { ...resolversToGenerate };
     /**
-     * PropertyAssignment
+     * Mark a resolver as implemented if the object literal already has a member
+     * with that name, in any of these forms (single traversal over the statement):
      * ```
      * const name = () => {};
      * const OutputType = {
-     *   id: () => {},
-     *   name: name,
+     *   id: () => {},   // PropertyAssignment
+     *   greet(){},      // MethodDeclaration
+     *   name,           // ShorthandPropertyAssignment
      * }
      * ```
      */
-    variableStatement
-        .getDescendantsOfKind(SyntaxKind.PropertyAssignment)
-        .forEach((propertyAssignment) => {
-        const resolverName = propertyAssignment.getName();
-        if (resolversData[resolverName]) {
-            resolversData[resolverName].implemented = true;
+    variableStatement.forEachDescendant((node) => {
+        if (node.isKind(SyntaxKind.PropertyAssignment) ||
+            node.isKind(SyntaxKind.MethodDeclaration) ||
+            node.isKind(SyntaxKind.ShorthandPropertyAssignment)) {
+            const resolverName = node.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
+    // 2. Add missing resolver properties if they haven't been implemented.
+    // Resolve the object literal once, not once per added property.
+    const objectLiteralExpression = variableStatement.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)[0];
     Object.values(resolversData).forEach(({ resolverName, resolverDeclaration, implemented }) => {
         if (implemented) {
             return;
         }
-        const addedNode = variableStatement
-            .getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression)[0]
-            .addPropertyAssignment({
+        const addedNode = objectLiteralExpression.addPropertyAssignment({
             name: resolverName,
             initializer: resolverDeclaration,
         });

package/dist/generateResolverFiles/postProcessFiles.js

@@ -1,3 +1,4 @@
+import { SyntaxKind } from 'ts-morph';
 import * as path from 'path';
 import { cwd } from '../utils/index.js';
 import { getVariableStatementWithExpectedIdentifier } from './getVariableStatementWithExpectedIdentifier.js';
@@ -43,7 +44,7 @@ export const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectType
     const addedPropertyAssignmentNodes = {};
     sourceFilesToProcess.forEach(({ sourceFile, resolverFile }) => {
         const normalizedRelativePath = path.posix.relative(cwd(), sourceFile.getFilePath());
-        const { addedVariableStatement } = ensureExportedResolver(sourceFile, resolverFile);
+        const { addedVariableStatement, variableStatement } = 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
@@ -56,6 +57,7 @@ export const postProcessFiles = ({ config: { tsMorph: { project }, fixObjectType
             addObjectTypeResolversPropertyAssignmentNodesIfNotImplemented({
                 addedPropertyAssignmentNodes,
                 sourceFile,
+                variableStatement,
                 resolverFile,
                 mode: fixObjectTypeResolvers.object,
             });
@@ -169,9 +171,13 @@ const ensureExportedResolver = (sourceFile, resolverFile) => {
     }
     if (!variableStatement) {
         // Did not find variable statement with expected identifier, add it to the end with a warning
-        sourceFile.addStatements(resolverFile.meta.variableStatement);
+        const addedStatements = sourceFile.addStatements(resolverFile.meta.variableStatement);
         resolverFile.filesystem.contentUpdated = true;
-        return { addedVariableStatement: true };
+        const addedVariableStatementNode = addedStatements.find((statement) => statement.isKind(SyntaxKind.VariableStatement));
+        return {
+            addedVariableStatement: true,
+            variableStatement: addedVariableStatementNode,
+        };
     }
     else if (variableStatement && !isExported) {
         // If has identifier but not exported
@@ -184,9 +190,9 @@ const ensureExportedResolver = (sourceFile, resolverFile) => {
             resolverFile.filesystem.contentUpdated = true;
         }
         // else, if identifier's been exported do nothing
-        return { addedVariableStatement: false };
+        return { addedVariableStatement: false, variableStatement };
     }
-    return { addedVariableStatement: false };
+    return { addedVariableStatement: false, variableStatement };
 };
 /**
  * Ensure correctly imported resolves type generated by typescript-resolvers plugin

package/dist/getGraphQLObjectTypeResolversToGenerate/cache.d.ts

@@ -0,0 +1,15 @@
+import type { Project, SourceFile } from 'ts-morph';
+import type { TypeMappersMap } from '../parseTypeMappers/index.js';
+import type { GraphQLObjectTypeResolversToGenerate } from './getGraphQLObjectTypeResolversToGenerate.js';
+type Cache = {
+    get(key: string): GraphQLObjectTypeResolversToGenerate | undefined;
+    set(key: string, value: GraphQLObjectTypeResolversToGenerate): GraphQLObjectTypeResolversToGenerate;
+    createCacheKey({ mode, typesSourceFile, typeMappersMap, tsMorphProject, }: {
+        mode: string;
+        typesSourceFile: SourceFile;
+        typeMappersMap: TypeMappersMap;
+        tsMorphProject: Project;
+    }): string;
+};
+export declare const createCache: () => Cache;
+export {};

package/dist/getGraphQLObjectTypeResolversToGenerate/cache.js

@@ -0,0 +1,83 @@
+import { createHash } from 'crypto';
+/**
+ * Maximum number of entries kept in the cache. Each entry corresponds to one
+ * distinct `(mode + types file + mappers)` state. A long watch session can visit
+ * many such states, and separate `generates` targets each contribute their own
+ * key, so we keep the N most-recently-used entries and evict the rest to bound
+ * memory. N is comfortably larger than the number of concurrent targets a single
+ * codegen run has.
+ */
+const MAX_CACHE_ENTRIES = 50;
+export const createCache = () => {
+    /**
+     * Cache of previous runs' results, so the ts-morph type-checker work is skipped
+     * when nothing it depends on has changed (e.g. a watch re-run where only a
+     * resolver implementation file was edited). The result is a pure function of
+     * - `mode`
+     * - the generated types file
+     * - the mapper file contents
+     *
+     * so the key is a hash of exactly those. Reused only on an exact key match, so
+     * it can never go stale. A `Map` is used because its insertion order gives a
+     * cheap LRU: the first key is the least-recently-used.
+     */
+    const resultCache = new Map();
+    return {
+        get(key) {
+            const result = resultCache.get(key);
+            if (result === undefined) {
+                return undefined;
+            }
+            // Mark as most-recently-used by re-inserting at the end.
+            resultCache.delete(key);
+            resultCache.set(key, result);
+            return structuredClone(result);
+        },
+        /**
+         * set
+         * Create a structured clone in the cache
+         * because downstream can update the value object
+         */
+        set(key, value) {
+            // Re-insert so this key becomes the most-recently-used entry.
+            resultCache.delete(key);
+            resultCache.set(key, structuredClone(value));
+            // Evict least-recently-used entries beyond the cap.
+            while (resultCache.size > MAX_CACHE_ENTRIES) {
+                const lruKey = resultCache.keys().next().value;
+                if (lruKey === undefined) {
+                    break;
+                }
+                resultCache.delete(lruKey);
+            }
+            return value;
+        },
+        /**
+         * Hash of everything the result depends on: the mode, the generated types file
+         * text (captures all schema-derived inputs), and each mapper file's contents.
+         * Same key => same result.
+         */
+        createCacheKey({ mode, typesSourceFile, typeMappersMap, tsMorphProject }) {
+            const hash = createHash('sha1');
+            hash.update(mode);
+            hash.update(' ');
+            hash.update(typesSourceFile.getFullText());
+            // The parsed mapper map (which schema type -> which mapper declaration) depends
+            // on config such as mappersSuffix, so hash it too: mapper file text alone would
+            // not distinguish two configs that read the same files differently.
+            hash.update(' ');
+            hash.update(JSON.stringify(Object.entries(typeMappersMap).sort(([a], [b]) => (a < b ? -1 : 1))));
+            const mapperFilenames = [
+                ...new Set(Object.values(typeMappersMap).map((m) => m.mapper.filename)),
+            ].sort();
+            for (const filename of mapperFilenames) {
+                const sourceFile = tsMorphProject.getSourceFile(filename);
+                hash.update(' ');
+                hash.update(filename);
+                hash.update(' ');
+                hash.update(sourceFile ? sourceFile.getFullText() : '');
+            }
+            return hash.digest('hex');
+        },
+    };
+};

package/dist/getGraphQLObjectTypeResolversToGenerate/getGraphQLObjectTypeResolversToGenerate.js

@@ -1,10 +1,22 @@
 import { SyntaxKind, Node, } from 'ts-morph';
 import { getNodePropertyMap, } from './getNodePropertyMap.js';
+import { createCache } from './cache.js';
+const cache = createCache();
 export const getGraphQLObjectTypeResolversToGenerate = ({ mode, tsMorphProject, typesSourceFile, typeMappersMap, userDefinedSchemaObjectTypeMap, generatedTypesFileMeta, }) => {
     const typeMappersEntries = Object.entries(typeMappersMap);
     if (typeMappersEntries.length === 0) {
         return {};
     }
+    const cacheKey = cache.createCacheKey({
+        mode,
+        typesSourceFile,
+        typeMappersMap,
+        tsMorphProject,
+    });
+    const cachedResult = cache.get(cacheKey);
+    if (cachedResult) {
+        return cachedResult;
+    }
     /**
      * `generatedTypesFileMeta.generatedResolverTypes.userDefined` is `schemaType` -> `generatedResolverTypes`
      * We will be parsing `types.generated.ts` file for the `generatedResolverTypes`
@@ -27,6 +39,7 @@ export const getGraphQLObjectTypeResolversToGenerate = ({ mode, tsMorphProject,
         res[generatedSchemaTypeName.name] = schemaType;
         return res;
     }, {});
+    // "Fast" mode
     if (mode === 'fast') {
         // 1. Get property map of all schema types
         const resolverTypesMap = {};
@@ -105,8 +118,10 @@ export const getGraphQLObjectTypeResolversToGenerate = ({ mode, tsMorphProject,
                 };
             });
         });
-        return result;
+        const newResult = cache.set(cacheKey, result);
+        return newResult;
     }
+    // "Smart" mode
     // 1. Get property map of all schema types
     const schemaResolversTypePropertyMap = {};
     const populateSchemaTypeResolversPropertyMap = (node) => {
@@ -181,7 +196,8 @@ export const getGraphQLObjectTypeResolversToGenerate = ({ mode, tsMorphProject,
             return;
         });
     });
-    return result;
+    const newResult = cache.set(cacheKey, result);
+    return newResult;
 };
 const mustGetMapperOriginalDeclarationNode = ({ tsMorphProject, mapper, }) => {
     const typeMapperFile = tsMorphProject.getSourceFile(mapper.filename);

package/dist/preset.js

@@ -151,6 +151,10 @@ export const preset = {
                     plugins: [{ add: { content: meta.content } }],
                     config: {},
                     schema,
+                    // Pass schemaAst so codegen-core reuses the prebuilt schema instead of
+                    // rebuilding one per output (O(types) each -> O(types^2) overall). This
+                    // is an `add`-only output, so the schema doesn't affect its content.
+                    schemaAst,
                     documents: [],
                 };
                 generatesSection.push(typeDefsFile);
@@ -214,7 +218,17 @@ export const preset = {
                 plugins: [{ add: { content } }],
                 config: {},
                 schema,
+                // Pass schemaAst so codegen-core reuses the prebuilt schema instead of
+                // rebuilding one per output (O(types) each -> O(types^2) overall). This
+                // is an `add`-only output, so the schema doesn't affect its content.
+                schemaAst,
                 documents: [],
+                // Forces Codegen to compare generated content vs on disk, instead of in-memory cache
+                // This avoids situation where resolver files are content on disk are updated,
+                // and goes out of sync with the in-memory cache version, and can lead to generated
+                // content not getting written to disk
+                // https://github.com/dotansimha/graphql-code-generator/pull/10928
+                contentComparison: 'disk',
             };
         });
         logger.debug(`Applying changes to ${resolverFilesGenerateOptions.length}/${resultFilesArray.length} files. (${resultFilesArray.length - resolverFilesGenerateOptions.length} skipped files because they are already on filesystem and are not updated)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eddeee888/gcg-typescript-resolver-files",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/eddeee888/graphql-code-generator-plugins.git",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@graphql-codegen/add": "^7.1.0",
-    "@graphql-codegen/plugin-helpers": "^7.2.1",
+    "@graphql-codegen/plugin-helpers": "^7.3.0",
     "@graphql-codegen/schema-ast": "^6.1.0",
     "@graphql-codegen/typescript": "^6.1.0",
     "@graphql-codegen/typescript-resolvers": "^6.1.0",