@trackunit/react-graphql-tools 1.11.78 → 1.12.1

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 1.12.1 (2026-03-20)
+
+### 🧱 Updated Dependencies
+
+- Updated react-test-setup to 1.8.76
+
+## 1.12.0 (2026-03-19)
+
+### 🚀 Features
+
+- improve GraphQL mock generation for tests ([#22330](https://github.com/Trackunit/manager/pull/22330))
+
+### ❤️ Thank You
+
+- Kieran Prince @kpr-trackunit
+
 ## 1.11.78 (2026-03-19)
 
 ### 🧱 Updated Dependencies

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/react-graphql-tools",
-  "version": "1.11.78",
+  "version": "1.12.1",
   "main": "src/index.js",
   "executors": "./executors.json",
   "generators": "./generators.json",
@@ -10,14 +10,14 @@
     "node": ">=24.x"
   },
   "dependencies": {
-    "@nx/devkit": "22.4.4",
     "@graphql-codegen/cli": "^5.0.3",
     "@graphql-codegen/client-preset": "^4.5.1",
     "prettier": "^3.4.2",
     "ts-morph": "^20.0.0",
     "@faker-js/faker": "^8.4.1",
     "win-ca": "^3.5.1",
-    "tslib": "^2.6.2"
+    "tslib": "^2.6.2",
+    "@nx/devkit": "22.4.4"
   },
   "types": "./src/index.d.ts",
   "type": "commonjs"

package/src/executors/createHooks/scrubMockFile.js

@@ -4,6 +4,215 @@ exports.scrubMockFileContent = void 0;
 /* eslint-disable no-console */
 const faker_1 = require("@faker-js/faker");
 const ts_morph_1 = require("ts-morph");
+const UNDEFINED_SENTINEL = "__UNDEFINED__";
+/**
+ * Strips surrounding double-quotes from a ts-morph property name.
+ * Codegen may emit JSON-style keys (`"kind"`) whose getName() includes the quotes.
+ */
+const stripQuotes = (name) => (name.startsWith('"') && name.endsWith('"') ? name.slice(1, -1) : name);
+/**
+ * Finds a property in an object literal by name, handling both quoted and unquoted keys.
+ */
+const findProperty = (obj, name) => obj.getProperty(name) ?? obj.getProperty(`"${name}"`);
+/**
+ * Resolves the type of a property symbol in the context of a source file.
+ * Uses the TypeChecker to correctly handle mapped types like Exact<{...}>.
+ */
+const getPropertyType = (prop, sourceFile) => {
+    return sourceFile.getProject().getTypeChecker().getTypeOfSymbolAtLocation(prop, sourceFile);
+};
+/**
+ * Checks whether a type is an InputMaybe union (contains null or undefined members).
+ * Required unions like `string | string[]` or enums do NOT match.
+ */
+const isInputMaybe = (type) => type.isUnion() && type.getUnionTypes().some(m => m.isNull() || m.isUndefined());
+/**
+ * Returns the names of required variable fields (those whose type is NOT
+ * wrapped in InputMaybe, i.e. not a union containing null/undefined).
+ */
+const getRequiredVariableKeys = (variablesType, sourceFile) => {
+    return variablesType
+        .getProperties()
+        .filter(prop => !isInputMaybe(getPropertyType(prop, sourceFile)))
+        .map(prop => prop.getName());
+};
+/**
+ * Generates default variable values for GraphQL query/mutation variables.
+ *
+ * - InputMaybe<T> (union with null/undefined) -> UNDEFINED_SENTINEL
+ * - Required union (e.g. string | string[], enums) -> faker value from first concrete member
+ * - Required scalar -> faker value
+ * - Required object -> recursively expanded
+ */
+const generateDefaultFromInputType = (type, sourceFile, depth = 0) => {
+    if (depth > 10)
+        return UNDEFINED_SENTINEL;
+    if (isInputMaybe(type)) {
+        return UNDEFINED_SENTINEL;
+    }
+    if (type.isUnion()) {
+        const firstMember = type.getUnionTypes()[0];
+        if (!firstMember)
+            return UNDEFINED_SENTINEL;
+        return generateDefaultFromInputType(firstMember, sourceFile, depth);
+    }
+    if (type.isArray()) {
+        const elementType = type.getArrayElementType();
+        if (!elementType)
+            return UNDEFINED_SENTINEL;
+        const elementDefault = generateDefaultFromInputType(elementType, sourceFile, depth + 1);
+        if (elementDefault === UNDEFINED_SENTINEL)
+            return [];
+        return [elementDefault];
+    }
+    if (type.isObject()) {
+        const properties = type.getProperties();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const obj = {};
+        for (const prop of properties) {
+            const propType = getPropertyType(prop, sourceFile);
+            obj[prop.getName()] = generateDefaultFromInputType(propType, sourceFile, depth + 1);
+        }
+        return obj;
+    }
+    if (type.isStringLiteral())
+        return type.getLiteralValue();
+    if (type.isNumberLiteral())
+        return type.getLiteralValue();
+    if (type.isBooleanLiteral())
+        return type.getText() === "true";
+    const typeText = type.getText();
+    if (typeText === "string" || typeText === "number" || typeText === "boolean") {
+        faker_1.faker.seed(123);
+        if (typeText === "string")
+            return faker_1.faker.lorem.word();
+        if (typeText === "number")
+            return faker_1.faker.number.int();
+        return false;
+    }
+    return UNDEFINED_SENTINEL;
+};
+const parseGraphqlDefaultValue = (kind, rawValue) => {
+    switch (kind) {
+        case "BooleanValue":
+            return rawValue === "true";
+        case "IntValue":
+            return rawValue ? parseInt(rawValue.replace(/"/g, ""), 10) : 0;
+        case "FloatValue":
+            return rawValue ? parseFloat(rawValue.replace(/"/g, "")) : 0;
+        case "StringValue":
+            return rawValue ? rawValue.replace(/^"|"$/g, "") : "";
+        case "EnumValue":
+            return rawValue ? rawValue.replace(/^"|"$/g, "") : undefined;
+        case "NullValue":
+            return null;
+        default:
+            return undefined;
+    }
+};
+/**
+ * Navigates variable -> name -> value inside a VariableDefinition object literal
+ * to extract the GraphQL variable name.
+ */
+const extractVarDefName = (obj) => {
+    const varProp = obj
+        .getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment)
+        .find(p => stripQuotes(p.getName()) === "variable");
+    if (!varProp)
+        return undefined;
+    const varInit = varProp.getInitializer();
+    if (!varInit || !ts_morph_1.Node.isObjectLiteralExpression(varInit))
+        return undefined;
+    const namePropInner = varInit
+        .getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment)
+        .find(p => stripQuotes(p.getName()) === "name");
+    if (!namePropInner)
+        return undefined;
+    const nameInit = namePropInner.getInitializer();
+    if (!nameInit || !ts_morph_1.Node.isObjectLiteralExpression(nameInit))
+        return undefined;
+    const valuePropInner = nameInit
+        .getChildrenOfKind(ts_morph_1.SyntaxKind.PropertyAssignment)
+        .find(p => stripQuotes(p.getName()) === "value");
+    if (!valuePropInner)
+        return undefined;
+    return valuePropInner.getInitializer()?.getText().replace(/"/g, "");
+};
+/**
+ * Extracts GraphQL-level default values from the DocumentNode AST constant.
+ * e.g. `$withValues: Boolean = true` produces
+ * `defaultValue: { kind: "BooleanValue", value: true }` in the generated TypeScript.
+ */
+const extractGraphqlDefaultValues = (sourceFile, documentName) => {
+    const defaults = {};
+    const decl = sourceFile.getVariableDeclaration(documentName);
+    if (!decl)
+        return defaults;
+    const objectLiterals = decl.getDescendantsOfKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+    for (const obj of objectLiterals) {
+        const kindProp = findProperty(obj, "kind");
+        if (!kindProp || !ts_morph_1.Node.isPropertyAssignment(kindProp))
+            continue;
+        if (kindProp.getInitializer()?.getText() !== '"VariableDefinition"')
+            continue;
+        const dvProp = findProperty(obj, "defaultValue");
+        if (!dvProp || !ts_morph_1.Node.isPropertyAssignment(dvProp))
+            continue;
+        const dvInit = dvProp.getInitializer();
+        if (!dvInit || !ts_morph_1.Node.isObjectLiteralExpression(dvInit))
+            continue;
+        const varName = extractVarDefName(obj);
+        if (!varName)
+            continue;
+        const dvKindProp = findProperty(dvInit, "kind");
+        if (!dvKindProp || !ts_morph_1.Node.isPropertyAssignment(dvKindProp))
+            continue;
+        const dvKind = dvKindProp.getInitializer()?.getText().replace(/"/g, "");
+        let dvValue;
+        const dvValueProp = findProperty(dvInit, "value");
+        if (dvValueProp && ts_morph_1.Node.isPropertyAssignment(dvValueProp)) {
+            dvValue = dvValueProp.getInitializer()?.getText();
+        }
+        const parsed = parseGraphqlDefaultValue(dvKind, dvValue);
+        if (parsed !== undefined) {
+            defaults[varName] = parsed;
+        }
+    }
+    return defaults;
+};
+/**
+ * Serializes a value to JavaScript source code, emitting `undefined` for sentinel values.
+ * JSON.stringify drops undefined, so we need a custom serializer.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const serializeToSource = (value, indent = 0) => {
+    const pad = " ".repeat(indent);
+    const innerPad = " ".repeat(indent + 4);
+    if (value === UNDEFINED_SENTINEL)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        const items = value.map(v => `${innerPad}${serializeToSource(v, indent + 4)}`).join(",\n");
+        return `[\n${items}\n${pad}]`;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0)
+            return "{}";
+        const props = entries
+            .map(([k, v]) => `${innerPad}${JSON.stringify(k)}: ${serializeToSource(v, indent + 4)}`)
+            .join(",\n");
+        return `{\n${props}\n${pad}}`;
+    }
+    return "undefined";
+};
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const generateMockFromType = (type, text) => {
     faker_1.faker.seed(123);
@@ -16,13 +225,13 @@ const generateMockFromType = (type, text) => {
     if (rightSideText.startsWith("[number, number] | [number, number][] | [number, number][][]")) {
         return "[[1, 2], [3, 4]]";
     }
-    if (type.isStringLiteral()) {
+    if (Boolean(type.isStringLiteral())) {
         return type.compilerType.value; // Get the value of the string literal
     }
-    if (type.isNumberLiteral()) {
+    if (Boolean(type.isNumberLiteral())) {
         return parseFloat(type.compilerType.value);
     }
-    if (type.isBooleanLiteral()) {
+    if (Boolean(type.isBooleanLiteral())) {
         return type.compilerType.value === "true";
     }
     if (type.getText() === "string") {
@@ -34,14 +243,14 @@ const generateMockFromType = (type, text) => {
     if (type.getText() === "Date" || type.getText() === "DateTime") {
         return "2023-01-22T15:08:12.527Z";
     }
-    if (type.isUnion()) {
-        // We'll take the first type in the union for simplicity
-        return generateMockFromType(type.getUnionTypes()[0], "");
+    if (Boolean(type.isUnion())) {
+        const nonNullish = type.getUnionTypes().filter((m) => !m.isNull() && !m.isUndefined());
+        return generateMockFromType(nonNullish[0] ?? type.getUnionTypes()[0], "");
     }
-    if (type.isArray()) {
+    if (Boolean(type.isArray())) {
         return [generateMockFromType(type.getArrayElementTypeOrThrow(), "")];
     }
-    if (type.isObject()) {
+    if (Boolean(type.isObject())) {
         const properties = type.getProperties();
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const obj = {};
@@ -49,7 +258,17 @@ const generateMockFromType = (type, text) => {
             const declaration = prop.getValueDeclarationOrThrow();
             const propType = declaration.getType();
             if (prop.getName() === "__typename") {
-                obj[prop.getName()] = propType.getText().replace(/"/g, "");
+                let typenameType = propType;
+                if (Boolean(typenameType.isUnion())) {
+                    const real = typenameType.getUnionTypes().filter((m) => !m.isNull() && !m.isUndefined());
+                    typenameType = real[0] ?? typenameType;
+                }
+                obj[prop.getName()] = Boolean(typenameType.isStringLiteral())
+                    ? typenameType.compilerType.value
+                    : typenameType
+                        .getText()
+                        .replace(/"/g, "")
+                        .replace(/ \| undefined/g, "");
             }
             else {
                 obj[prop.getName()] = generateMockFromType(propType, declaration.getText());
@@ -68,6 +287,7 @@ const scrubMockFileContent = async (fileContent, nxRoot, isVerbose) => {
         compilerOptions: {
             noUnusedLocals: true,
             noUnusedParameters: true,
+            strictNullChecks: true,
         },
     });
     const generatedFile = project.createSourceFile("tmpMock.ts", fileContent);
@@ -89,10 +309,46 @@ const scrubMockFileContent = async (fileContent, nxRoot, isVerbose) => {
     }
     const mock = mockThese.map(mocker => {
         const postFix = (mocker.getName().includes("Query") ? "Query" : "Mutation").length;
-        return `
-    
-    export const mockFor${mocker.getName()} = (variables: gql.${mocker.getName()}Variables, data?: DeepPartialNullable<gql.${mocker.getName()}> ) => {
-      return queryFor(gql.${mocker.getName().substring(0, mocker.getName().length - postFix)}Document, variables, 
+        const variablesTypeName = `${mocker.getName()}Variables`;
+        const variablesTypeAlias = generatedFile.getTypeAlias(variablesTypeName);
+        const docName = mocker.getName().substring(0, mocker.getName().length - postFix);
+        const typeDefaults = variablesTypeAlias
+            ? generateDefaultFromInputType(variablesTypeAlias.getType(), generatedFile)
+            : {};
+        const graphqlDefaults = extractGraphqlDefaultValues(generatedFile, `${docName}Document`);
+        const defaultVars = Object.keys(graphqlDefaults).length > 0 &&
+            typeDefaults &&
+            typeof typeDefaults === "object" &&
+            !Array.isArray(typeDefaults)
+            ? Object.assign({}, typeDefaults, graphqlDefaults)
+            : typeDefaults;
+        const requiredKeys = variablesTypeAlias ? getRequiredVariableKeys(variablesTypeAlias.getType(), generatedFile) : [];
+        let variablesParam;
+        if (requiredKeys.length === 0) {
+            variablesParam = `variables?: DeepPartialNullable<gql.${variablesTypeName}>`;
+        }
+        else {
+            const keysUnion = requiredKeys.map(k => `"${k}"`).join(" | ");
+            const requiredDeepPartial = `PickDeepPartialNullable<gql.${variablesTypeName}, ${keysUnion}>`;
+            const hasOptionalKeys = variablesTypeAlias
+                ? variablesTypeAlias.getType().getProperties().length > requiredKeys.length
+                : false;
+            const varType = hasOptionalKeys
+                ? `${requiredDeepPartial} & DeepPartialNullable<Omit<gql.${variablesTypeName}, ${keysUnion}>>`
+                : requiredDeepPartial;
+            variablesParam = `variables: ${varType}`;
+        }
+        const defaultVarsSource = serializeToSource(defaultVars, 4);
+        const isEmptyDefault = defaultVarsSource === "{}";
+        const defaultVarsRef = isEmptyDefault ? "{}" : `default${mocker.getName()}Variables`;
+        const constBlock = isEmptyDefault
+            ? ""
+            : `
+    const default${mocker.getName()}Variables: gql.${variablesTypeName} = ${defaultVarsSource};
+`;
+        return `${constBlock}
+    export const mockFor${mocker.getName()} = (${variablesParam}, data?: DeepPartialNullable<gql.${mocker.getName()}> ) => {
+      return queryFor(gql.${docName}Document, mergeDeepVars(${defaultVarsRef}, variables),
         mergeDeep(
           ${JSON.stringify(generateMockFromType(mocker.getType(), ""), null, 4)}
         , data || {}) as gql.${mocker.getName()}
@@ -100,11 +356,10 @@ const scrubMockFileContent = async (fileContent, nxRoot, isVerbose) => {
     }`;
     });
     return `
-  import { OperationVariables } from "@apollo/client";
   import { mergeDeep } from "@apollo/client/utilities";
-  import { queryFor, DeepPartialNullable } from "@trackunit/react-core-contexts-test";
+  import { mergeDeepVars, queryFor, DeepPartialNullable, PickDeepPartialNullable } from "@trackunit/react-core-contexts-test";
   import * as gql from "./graphql";
-  
+
   ${mock.join("\n")}
   `;
 };