@trackunit/react-graphql-tools 1.14.45 → 1.14.47

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.14.47 (2026-06-30)
+
+### 🧱 Updated Dependencies
+
+- Updated react-vite-test-setup to 0.0.47
+
+## 1.14.46 (2026-06-29)
+
+This was a version bump only for react-graphql-tools to align it with other projects, there were no code changes.
+
 ## 1.14.45 (2026-06-29)
 
 ### 🧱 Updated Dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/react-graphql-tools",
-  "version": "1.14.45",
+  "version": "1.14.47",
   "main": "src/index.js",
   "executors": "./executors.json",
   "generators": "./generators.json",

package/src/executors/createHooks/scrubFile.js

@@ -6,14 +6,15 @@ const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const prettier = tslib_1.__importStar(require("prettier"));
+const ts_morph_1 = require("ts-morph");
 const scrubMockFile_1 = require("./scrubMockFile");
 const utils_1 = require("./utils");
 /**
  *  Generates React hooks from your graphql files.
  */
-const scrubFileContent = async (fileContent, nxRoot, isVerbose) => {
+const scrubFileContent = async (fileContent, nxRoot, isVerbose, providedSourceFile) => {
     const start = new Date().getTime();
-    const sourceFile = (0, utils_1.createSourceFile)(fileContent);
+    const sourceFile = providedSourceFile ?? (0, utils_1.createSourceFile)(fileContent);
     let resultFileContent = "";
     const scalarsType = sourceFile.getTypeAliasOrThrow("Scalars");
     scalarsType.getEndLineNumber();
@@ -29,14 +30,14 @@ const scrubFileContent = async (fileContent, nxRoot, isVerbose) => {
     }
     sourceFile.getEnums().forEach(enumType => {
         const typeName = enumType.getName();
-        if (preservedTypes.includes(typeName) && !alreadyAdded.includes(typeName) && !(0, utils_1.isFragment)(typeName)) {
+        if (preservedTypes.has(typeName) && !alreadyAdded.includes(typeName) && !(0, utils_1.isFragment)(typeName)) {
             alreadyAdded.push(typeName);
             resultFileContent += "\n" + (0, utils_1.convertEnumToConstObject)(enumType) + "\n";
         }
     });
     sourceFile.getTypeAliases().forEach(typeAlias => {
         const typeName = typeAlias.getName();
-        if (preservedTypes.includes(typeName) && !alreadyAdded.includes(typeName) && !(0, utils_1.isFragment)(typeName)) {
+        if (preservedTypes.has(typeName) && !alreadyAdded.includes(typeName) && !(0, utils_1.isFragment)(typeName)) {
             alreadyAdded.push(typeName);
             resultFileContent += "\n" + typeAlias.getText() + "\n";
         }
@@ -61,8 +62,20 @@ const scrubFile = async (file, nxRoot, isVerbose) => {
     if (fileContent.length === 0) {
         console.warn(`File ${file} is empty`);
     }
-    const scrubbedMockFileContent = await (0, scrubMockFile_1.scrubMockFileContent)(fileContent, nxRoot, isVerbose);
-    const scrubbedFileContent = await (0, exports.scrubFileContent)(fileContent, nxRoot, isVerbose);
+    // Parse the (large) generated file into ts-morph once and share it between the main and mock scrub
+    // instead of parsing it twice. Use the mock's stricter compiler options (the main scrub doesn't use
+    // the TypeChecker, so they don't affect its output).
+    const sharedSourceFile = new ts_morph_1.Project({
+        compilerOptions: {
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            strictNullChecks: true,
+        },
+    }).createSourceFile("tmp.ts", fileContent);
+    // The main scrub reads line numbers from the pristine AST, so it must run before the mock scrub
+    // mutates the shared source file via insertStatements().
+    const scrubbedFileContent = await (0, exports.scrubFileContent)(fileContent, nxRoot, isVerbose, sharedSourceFile);
+    const scrubbedMockFileContent = await (0, scrubMockFile_1.scrubMockFileContent)(fileContent, nxRoot, isVerbose, sharedSourceFile);
     let options = null;
     try {
         options = prettier

package/src/executors/createHooks/scrubMockFile.js

@@ -281,16 +281,16 @@ const generateMockFromType = (type, text) => {
 /**
  *  Generates React hooks from your graphql files.
  */
-const scrubMockFileContent = async (fileContent, nxRoot, isVerbose) => {
+const scrubMockFileContent = async (fileContent, nxRoot, isVerbose, providedSourceFile) => {
     const start = new Date().getTime();
-    const project = new ts_morph_1.Project({
-        compilerOptions: {
-            noUnusedLocals: true,
-            noUnusedParameters: true,
-            strictNullChecks: true,
-        },
-    });
-    const generatedFile = project.createSourceFile("tmpMock.ts", fileContent);
+    const generatedFile = providedSourceFile ??
+        new ts_morph_1.Project({
+            compilerOptions: {
+                noUnusedLocals: true,
+                noUnusedParameters: true,
+                strictNullChecks: true,
+            },
+        }).createSourceFile("tmpMock.ts", fileContent);
     const mockThese = [];
     generatedFile.insertStatements(0, "/* eslint-disable @typescript-eslint/no-explicit-any */");
     generatedFile.insertStatements(1, "/* eslint-disable @typescript-eslint/array-type */");

package/src/executors/createHooks/utils.js

@@ -70,26 +70,33 @@ const getFullPathUpOfNode = (node) => {
 const getPreservedTypes = (sourceFile, isVerbose) => {
     const typeAliases = sourceFile.getTypeAliases();
     const queryAndMutations = [];
-    const preservedTypes = [];
+    const preservedTypes = new Set();
     const variablesListToProcess = [];
     const queryMutationListToProcess = [];
     typeAliases.forEach(typeAlias => {
         const name = typeAlias.getName();
-        // Get the type literal node that contains the properties
-        const typeLiteral = typeAlias.getTypeNode()?.asKind(ts_morph_1.SyntaxKind.TypeLiteral);
-        let typeLiteralText = null;
-        if (typeLiteral) {
-            // Find the __typename property
-            const typenameProperty = typeLiteral.getProperties().find(prop => prop.getName() === "__typename");
-            if (typenameProperty) {
-                typeLiteralText = typenameProperty.getType().getText().replaceAll('"', "");
-            }
-        }
+        // Name-based classification needs no type info, so handle it first and skip resolving the
+        // `__typename` literal for the (many) *Variables / *Fragment aliases.
         if (isQueryVariables(name) || isMutationVariables(name) || isSubscriptionVariables(name) || (0, exports.isFragment)(name)) {
             variablesListToProcess.push(typeAlias);
             queryAndMutations.push(typeAlias);
+            return;
+        }
+        // Get the type literal node that contains the properties
+        const typeLiteral = typeAlias.getTypeNode()?.asKind(ts_morph_1.SyntaxKind.TypeLiteral);
+        if (!typeLiteral) {
+            return;
+        }
+        // Find the __typename property
+        const typenameProperty = typeLiteral.getProperties().find(prop => prop.getName() === "__typename");
+        if (!typenameProperty) {
+            return;
         }
-        else if (isQuery({ typeLiteralText, name }) ||
+        // Read the literal straight from the AST type node (`__typename?: 'Query'`) instead of asking the
+        // TypeChecker via `getType()`, which is dramatically faster on large generated files. The AST text
+        // keeps the source quote style (codegen emits single quotes), so strip both quote characters.
+        const typeLiteralText = (typenameProperty.getTypeNode()?.getText() ?? typenameProperty.getType().getText()).replace(/['"]/g, "");
+        if (isQuery({ typeLiteralText, name }) ||
             isMutation({ typeLiteralText, name }) ||
             isSubscription({ typeLiteralText, name })) {
             queryMutationListToProcess.push(typeAlias);
@@ -117,29 +124,32 @@ const getPreservedTypes = (sourceFile, isVerbose) => {
 };
 exports.getPreservedTypes = getPreservedTypes;
 const preserveTypes = (node, preservedTypes, sourceFile, isVerbose) => {
-    const typeReferences = [];
     node.forEachDescendant(descendant => {
-        if (descendant.getKind() === ts_morph_1.SyntaxKind.TypeReference &&
-            !descendant.getText().startsWith("Scalars") &&
-            !descendant.getText().startsWith("Maybe<") &&
-            !descendant.getText().startsWith("InputMaybe<") &&
-            !descendant.getText().startsWith("Array<") &&
-            !descendant.getText().startsWith("Exact<") &&
-            !descendant.getText().includes("__typename")) {
-            if (isVerbose) {
-                // eslint-disable-next-line no-console
-                console.log("ADDING", getFullPathUpOfNode(descendant), ":", descendant.getText(), descendant.getKindName());
-            }
-            if (!preservedTypes.includes(descendant.getText())) {
-                const foundTypeAlias = sourceFile.getTypeAlias(descendant.getText());
-                preservedTypes.push(descendant.getText());
-                if (foundTypeAlias) {
-                    preserveTypes(foundTypeAlias, preservedTypes, sourceFile, isVerbose);
-                }
+        if (descendant.getKind() !== ts_morph_1.SyntaxKind.TypeReference) {
+            return;
+        }
+        // `getText()` serialises the node's subtree, so compute it once instead of up to nine times.
+        const text = descendant.getText();
+        if (text.startsWith("Scalars") ||
+            text.startsWith("Maybe<") ||
+            text.startsWith("InputMaybe<") ||
+            text.startsWith("Array<") ||
+            text.startsWith("Exact<") ||
+            text.includes("__typename")) {
+            return;
+        }
+        if (isVerbose) {
+            // eslint-disable-next-line no-console
+            console.log("ADDING", getFullPathUpOfNode(descendant), ":", text, descendant.getKindName());
+        }
+        if (!preservedTypes.has(text)) {
+            const foundTypeAlias = sourceFile.getTypeAlias(text);
+            preservedTypes.add(text);
+            if (foundTypeAlias) {
+                preserveTypes(foundTypeAlias, preservedTypes, sourceFile, isVerbose);
             }
         }
     });
-    return typeReferences;
 };
 /**
  * Convert an enum to a const object and string literal type