@vladimirdev635/gql-codegen 0.0.109 → 0.0.111

package/actors/ts/graphql/actor.js

@@ -1,11 +1,11 @@
-import { writeFileSync } from 'fs';
-import { renderNodes } from '../shared.js';
+import { renderNodes, } from '../shared.js';
+import { executeRunAction } from '../../utils.js';
 import { generateNodes } from './generators/main.js';
-async function graphqlActor(config, context) {
+async function actor(config, context, action) {
     const nodes = generateNodes(config, context);
     const code = await renderNodes(config, nodes);
-    writeFileSync(config.outPath, code);
+    executeRunAction(config.outPath, action, code);
 }
-export function buildGraphqlActor(config) {
-    return (context) => graphqlActor(config, context);
+export function build(config) {
+    return (context, action) => actor(config, context, action);
 }

package/actors/ts/graphql/generators/client/fragments/document.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod/v4';
+import { RootSchema } from '../../../../../../schema/root.js';
+import { fragmentSchema } from '../../../../../../schema/client/fragment.js';
+import ts from 'typescript';
+export declare function generateFragmentDocumentNode(schema: RootSchema, name: string, fragment: z.infer<typeof fragmentSchema>): ts.VariableStatement;

package/actors/ts/graphql/generators/client/fragments/document.js

@@ -0,0 +1,10 @@
+import ts from 'typescript';
+import { extractFragmentSourceTextsInSpec } from './spec/shared.js';
+export function generateFragmentDocumentNode(schema, name, fragment) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(name + 'FragmentDocument'), undefined, undefined, ts.factory.createStringLiteral([
+            fragment.sourceText,
+            ...extractFragmentSourceTextsInSpec(schema, fragment.spec),
+        ].join(' '))),
+    ], ts.NodeFlags.Const));
+}

package/actors/ts/graphql/generators/client/fragments/index.d.ts

@@ -0,0 +1,4 @@
+import { RootSchema } from '../../../../../../schema/root.js';
+import ts from 'typescript';
+import { ScalarsMapping } from '../../server/scalars/mapping.js';
+export declare function generateFragmentTypes(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>): ts.Node[];

package/actors/ts/graphql/generators/client/fragments/index.js

@@ -0,0 +1,24 @@
+import { generateSchemaName, generateZodInferInterfaceType, generateZodInferTypeAlias, } from '../../server/shared.js';
+import { generateFragmentDocumentNode } from './document.js';
+import { generateZodFragmentSchema } from './schema.js';
+function generateFragmentDeclarations(scalarsMapping, schema, lazyFragmentsSet, fragmentName, fragment) {
+    const fName = fragmentName + 'Fragment';
+    const [fragmentSchemaNode, isLazy] = generateZodFragmentSchema(scalarsMapping, schema, lazyFragmentsSet, fragmentName, fragment);
+    if (isLazy) {
+        lazyFragmentsSet.add(fragmentName);
+    }
+    return [
+        generateFragmentDocumentNode(schema, fragmentName, fragment),
+        fragmentSchemaNode,
+        fragment.spec._type === 'ObjectFragmentSpec'
+            ? generateZodInferInterfaceType('output', fName, generateSchemaName(fName))
+            : generateZodInferTypeAlias('output', fName, generateSchemaName(fName)),
+    ];
+}
+export function generateFragmentTypes(scalarsMapping, schema, lazyFragmentsSet) {
+    return Object.entries(schema.client.fragments)
+        .map(([name, fragment]) => {
+        return generateFragmentDeclarations(scalarsMapping, schema, lazyFragmentsSet, name, fragment);
+    })
+        .flat();
+}

package/actors/ts/graphql/generators/client/fragments/schema.d.ts

@@ -0,0 +1,6 @@
+import { fragmentSchema } from '../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../schema/root.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../server/scalars/mapping.js';
+export declare function generateZodFragmentSchema(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, fragmentName: string, fragment: z.infer<typeof fragmentSchema>): [ts.VariableStatement, boolean];

package/actors/ts/graphql/generators/client/fragments/schema.js

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+import { generateSchemaName } from '../../server/shared.js';
+import { generateZodFragmentSpecCallExpression } from './spec/index.js';
+export function generateZodFragmentSchema(scalarsMapping, schema, lazyFragmentsSet, fragmentName, fragment) {
+    const [expression, isLazy] = generateZodFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, fragment.spec);
+    return [
+        ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(fragmentName + 'Fragment')), undefined, undefined, expression),
+        ], ts.NodeFlags.Const)),
+        isLazy,
+    ];
+}

package/actors/ts/graphql/generators/client/fragments/spec/index.d.ts

@@ -0,0 +1,5 @@
+import { RootSchema } from '../../../../../../../schema/root.js';
+import { ScalarsMapping } from '../../../server/scalars/mapping.js';
+import { FragmentSpecSchemaType } from '../../../../../../../schema/client/fragment.js';
+import { resolveSelections } from './shared.js';
+export declare function generateZodFragmentSpecCallExpression(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, spec: FragmentSpecSchemaType, typenameConfig?: Parameters<typeof resolveSelections>[1], insideLazy?: boolean): [import("typescript").CallExpression, boolean];

package/actors/ts/graphql/generators/client/fragments/spec/index.js

@@ -0,0 +1,8 @@
+import { generateZodObjectFragmentSpecCallExpression } from './object/index.js';
+import { generateZodUnionFragmentSpecCallExpression } from './union/index.js';
+export function generateZodFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, spec, typenameConfig, insideLazy = false) {
+    if (spec._type === 'ObjectFragmentSpec') {
+        return generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, schema.server.objects[spec.name], spec.selections, insideLazy, typenameConfig || { ensurePresent: true, optional: true });
+    }
+    return generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, spec, insideLazy);
+}

package/actors/ts/graphql/generators/client/fragments/spec/object/field_selection.d.ts

@@ -0,0 +1,7 @@
+import { fieldSelection } from '../../../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../../../schema/root.js';
+import { objectSchema } from '../../../../../../../../schema/server.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../../../server/scalars/mapping.js';
+export declare function generateFieldSelection(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, insideLazy: boolean, objectType: z.infer<typeof objectSchema>, selection: z.infer<typeof fieldSelection>): ts.PropertyAssignment;

package/actors/ts/graphql/generators/client/fragments/spec/object/field_selection.js

@@ -0,0 +1,27 @@
+import { invokeMethod } from '../../../../../../shared.js';
+import ts from 'typescript';
+import { generateZodObjectFieldSpec } from '../../../../server/objects.js';
+import { generateZodFragmentSpecCallExpression } from '../index.js';
+export function generateFieldSelection(scalarsMapping, schema, lazyFragmentsSet, insideLazy, objectType, selection) {
+    const fieldSpec = objectType.fields[selection.name];
+    let expression;
+    if (selection.selection == null) {
+        expression = generateZodObjectFieldSpec(scalarsMapping, fieldSpec);
+    }
+    else {
+        const optional = fieldSpec.spec._type !== 'callable' ||
+            !selection.selection.selections.every((s) => s._type === 'TypenameField') ||
+            !fieldSpec.nullable;
+        // eslint-disable-next-line no-use-before-define
+        [expression] = generateZodFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, selection.selection, { ensurePresent: true, optional }, insideLazy);
+        if (fieldSpec.spec._type === 'array' ||
+            (fieldSpec.spec._type === 'callable' &&
+                fieldSpec.spec.returnType._type === 'array')) {
+            expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'array'), undefined, [expression]);
+        }
+    }
+    if (fieldSpec.nullable) {
+        expression = invokeMethod(invokeMethod(expression, 'nullable', []), 'optional', []);
+    }
+    return ts.factory.createPropertyAssignment(selection.alias, expression);
+}

package/actors/ts/graphql/generators/client/fragments/spec/object/index.d.ts

@@ -0,0 +1,8 @@
+import { objectSelection } from '../../../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../../../schema/root.js';
+import { objectSchema } from '../../../../../../../../schema/server.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../../../server/scalars/mapping.js';
+import { resolveSelections } from '../shared.js';
+export declare function generateZodObjectFragmentSpecCallExpression(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, object: z.infer<typeof objectSchema>, specSelections: z.infer<typeof objectSelection>[], insideLazy: boolean, typenameConfig: Parameters<typeof resolveSelections>[1]): [ts.CallExpression, boolean];

package/actors/ts/graphql/generators/client/fragments/spec/object/index.js

@@ -0,0 +1,23 @@
+import ts from 'typescript';
+import { resolveSelections } from '../shared.js';
+import { generateZodObjectSelection } from './selection.js';
+export function generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, object, specSelections, insideLazy, typenameConfig) {
+    const selections = resolveSelections(specSelections, typenameConfig);
+    let needsLazy = false;
+    const properties = selections
+        .map((s) => {
+        const [property, pNeedsLazy] = generateZodObjectSelection(scalarsMapping, schema, lazyFragmentsSet, object, s, insideLazy, typenameConfig);
+        if (needsLazy === false && pNeedsLazy) {
+            needsLazy = true;
+        }
+        return property;
+    })
+        .filter((s) => s !== null);
+    let expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'object'), undefined, [ts.factory.createObjectLiteralExpression(properties, true)]);
+    if (needsLazy) {
+        expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'lazy'), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expression),
+        ]);
+    }
+    return [expression, needsLazy];
+}

package/actors/ts/graphql/generators/client/fragments/spec/object/selection.d.ts

@@ -0,0 +1,8 @@
+import { objectSelection } from '../../../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../../../schema/root.js';
+import { objectSchema } from '../../../../../../../../schema/server.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../../../server/scalars/mapping.js';
+import { resolveSelections } from '../shared.js';
+export declare function generateZodObjectSelection(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, objectType: z.infer<typeof objectSchema>, selection: z.infer<typeof objectSelection>, insideLazy: boolean, typenameConfig: Parameters<typeof resolveSelections>[1]): [ts.PropertyAssignment | ts.SpreadAssignment | null, boolean];

package/actors/ts/graphql/generators/client/fragments/spec/object/selection.js

@@ -0,0 +1,25 @@
+import { generateFieldSelection } from './field_selection.js';
+import { generateSpreadSelection } from './spread_selection.js';
+import { generateTypenameFieldSelection } from './typename_field.js';
+export function generateZodObjectSelection(scalarsMapping, schema, lazyFragmentsSet, objectType, selection, insideLazy, typenameConfig) {
+    switch (selection._type) {
+        case 'TypenameField': {
+            return [
+                generateTypenameFieldSelection(typenameConfig, objectType.name, selection),
+                false,
+            ];
+        }
+        case 'FieldSelection': {
+            return [
+                generateFieldSelection(scalarsMapping, schema, lazyFragmentsSet, insideLazy, objectType, selection),
+                false,
+            ];
+        }
+        case 'SpreadSelection': {
+            return [
+                generateSpreadSelection(selection.fragment, lazyFragmentsSet.has(selection.fragment)),
+                true,
+            ];
+        }
+    }
+}

package/actors/ts/graphql/generators/client/fragments/spec/object/spread_selection.d.ts

@@ -0,0 +1,2 @@
+import ts from 'typescript';
+export declare function generateSpreadSelection(fragmentName: string, isLazy: boolean): ts.SpreadAssignment;

package/actors/ts/graphql/generators/client/fragments/spec/object/spread_selection.js

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import { invokeMethod } from '../../../../../../shared.js';
+import { generateSchemaName } from '../../../../server/shared.js';
+function constructObjectWithShape(fragmentName, isLazy) {
+    const schemaName = generateSchemaName(fragmentName + 'Fragment');
+    const identifier = ts.factory.createIdentifier(schemaName);
+    if (!isLazy)
+        return identifier;
+    return invokeMethod(ts.factory.createPropertyAccessExpression(identifier, 'def'), 'getter', []);
+}
+export function generateSpreadSelection(fragmentName, isLazy) {
+    return ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(constructObjectWithShape(fragmentName, isLazy), ts.factory.createIdentifier('shape')));
+}

package/actors/ts/graphql/generators/client/fragments/spec/object/typename_field.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod/v4';
+import { resolveSelections } from '../shared.js';
+import ts from 'typescript';
+import { typenameSelection } from '../../../../../../../../schema/client/fragment.js';
+export declare function generateTypenameFieldSelection(typenameConfig: Parameters<typeof resolveSelections>[1], objectTypeName: string, selection: z.infer<typeof typenameSelection>): ts.PropertyAssignment | null;

package/actors/ts/graphql/generators/client/fragments/spec/object/typename_field.js

@@ -0,0 +1,13 @@
+import { invokeMethod } from '../../../../../../shared.js';
+import ts from 'typescript';
+export function generateTypenameFieldSelection(typenameConfig, objectTypeName, selection) {
+    if ('ignore' in typenameConfig)
+        return null;
+    let expression = invokeMethod(ts.factory.createIdentifier('z'), 'literal', [
+        ts.factory.createStringLiteral(objectTypeName),
+    ]);
+    if (selection.alias === null && typenameConfig.optional) {
+        expression = invokeMethod(invokeMethod(expression, 'nullable', []), 'optional', []);
+    }
+    return ts.factory.createPropertyAssignment(selection.alias || '__typename', expression);
+}

package/actors/ts/graphql/generators/client/{fragments.d.ts → fragments/spec/shared.d.ts}

@@ -1,11 +1,7 @@
-import ts from 'typescript';
-import { RootSchema } from '../../../../../schema/root.js';
-import { FragmentSpecSchemaType, objectSelection } from '../../../../../schema/client/fragment.js';
 import { z } from 'zod/v4';
-import { ScalarsMapping } from '../server/scalars/mapping.js';
-export declare function extractFragmentNamesInSpec(schema: RootSchema, fragmentSpec: FragmentSpecSchemaType): string[];
-export declare function extractFragmentSourceTextsInSpec(schema: RootSchema, fragmentSpec: FragmentSpecSchemaType): string[];
-declare function resolveSelections(specSelections: z.infer<typeof objectSelection>[], typenameConfig: {
+import { FragmentSpecSchemaType, objectSelection } from '../../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../../schema/root.js';
+export declare function resolveSelections(specSelections: z.infer<typeof objectSelection>[], typenameConfig: {
     ensurePresent: boolean;
     optional: boolean;
 } | {
@@ -90,6 +86,5 @@ declare function resolveSelections(specSelections: z.infer<typeof objectSelectio
         })[];
     } | null;
 })[];
-export declare function generateZodFragmentSpecCallExpression(scalarsMapping: ScalarsMapping, schema: RootSchema, spec: FragmentSpecSchemaType, typenameConfig?: Parameters<typeof resolveSelections>[1]): ts.CallExpression;
-export declare function generateFragmentTypes(scalarsMapping: ScalarsMapping, schema: RootSchema): ts.Node[];
-export {};
+export declare function extractFragmentNamesInSpec(schema: RootSchema, fragmentSpec: FragmentSpecSchemaType): string[];
+export declare function extractFragmentSourceTextsInSpec(schema: RootSchema, fragmentSpec: FragmentSpecSchemaType): string[];

package/actors/ts/graphql/generators/client/fragments/spec/shared.js

@@ -0,0 +1,59 @@
+import assert from 'assert';
+export function resolveSelections(specSelections, typenameConfig) {
+    const ignoreTypename = 'ignore' in typenameConfig;
+    const selections = specSelections
+        .filter((s) => s._type !== 'TypenameField' || !ignoreTypename)
+        .toSorted((s1, s2) => s1._type.localeCompare(s2._type));
+    if (ignoreTypename)
+        return selections;
+    const hasTypename = specSelections.some((s) => s._type === 'TypenameField');
+    const hasSpreadSelection = specSelections.some((s) => s._type === 'SpreadSelection');
+    if (!hasTypename) {
+        if (hasSpreadSelection) {
+            selections.push({ _type: 'TypenameField', alias: null });
+        }
+        else {
+            selections.unshift({ _type: 'TypenameField', alias: null });
+        }
+    }
+    return selections;
+}
+export function extractFragmentNamesInSpec(schema, fragmentSpec) {
+    if (fragmentSpec._type === 'UnionFragmentSpec') {
+        return fragmentSpec.selections
+            .map((s) => {
+            if (s._type === 'SpreadSelection') {
+                const fragment = schema.client.fragments[s.fragment];
+                return [
+                    s.fragment,
+                    ...extractFragmentNamesInSpec(schema, fragment.spec),
+                ];
+            }
+            if (s._type === 'ObjectConditionalSpreadSelection') {
+                return extractFragmentNamesInSpec(schema, s.spec);
+            }
+            return [];
+        })
+            .flat();
+    }
+    return fragmentSpec.selections
+        .map((s) => {
+        if (s._type === 'SpreadSelection') {
+            const fragment = schema.client.fragments[s.fragment];
+            assert(fragment.spec !== undefined);
+            return [
+                s.fragment,
+                ...extractFragmentNamesInSpec(schema, fragment.spec),
+            ];
+        }
+        if (s._type === 'FieldSelection' && s.selection != null) {
+            assert(s.selection !== undefined);
+            return extractFragmentNamesInSpec(schema, s.selection);
+        }
+        return [];
+    })
+        .flat();
+}
+export function extractFragmentSourceTextsInSpec(schema, fragmentSpec) {
+    return Array.from(new Set(extractFragmentNamesInSpec(schema, fragmentSpec))).map((f) => schema.client.fragments[f].sourceText);
+}

package/actors/ts/graphql/generators/client/fragments/spec/union/index.d.ts

@@ -0,0 +1,6 @@
+import { unionFragmentSpec } from '../../../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../../../schema/root.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../../../server/scalars/mapping.js';
+export declare function generateZodUnionFragmentSpecCallExpression(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, spec: z.infer<typeof unionFragmentSpec>, insideLazy: boolean): [ts.CallExpression, boolean];

package/actors/ts/graphql/generators/client/fragments/spec/union/index.js

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+import { generateZodObjectFragmentSpecCallExpression } from '../object/index.js';
+import { resolveUnionSelections } from './selections.js';
+export function generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, spec, insideLazy) {
+    const [objectSelections, typenameSelections] = resolveUnionSelections(schema, spec.selections);
+    for (const item of Object.keys(schema.server.unions[spec.name].items)) {
+        if (!objectSelections.some((s) => s.object === item)) {
+            objectSelections.push({
+                _type: 'ObjectConditionalSpreadSelection',
+                object: item,
+                spec: {
+                    _type: 'ObjectFragmentSpec',
+                    name: item,
+                    selections: [],
+                },
+            });
+        }
+    }
+    let expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'union'), undefined, [
+        ts.factory.createArrayLiteralExpression(objectSelections.map((s) => generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, schema.server.objects[s.object], [...s.spec.selections, ...typenameSelections], true, { ensurePresent: true, optional: false })[0]), true),
+    ]);
+    if (!insideLazy) {
+        expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'lazy'), undefined, [
+            ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expression),
+        ]);
+    }
+    return [expression, !insideLazy];
+}

package/actors/ts/graphql/generators/client/fragments/spec/union/selections.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod/v4';
+import { objectConditionalSpreadSelection, typenameSelection, UnionSelection } from '../../../../../../../../schema/client/fragment.js';
+import { RootSchema } from '../../../../../../../../schema/root.js';
+export declare function resolveUnionSelections(schema: RootSchema, specSelections: UnionSelection[]): [
+    z.infer<typeof objectConditionalSpreadSelection>[],
+    z.infer<typeof typenameSelection>[]
+];

package/actors/ts/graphql/generators/client/fragments/spec/union/selections.js

@@ -0,0 +1,21 @@
+import assert from 'assert';
+export function resolveUnionSelections(schema, specSelections) {
+    const typenameSelections = [];
+    const objectSelections = specSelections
+        .map((s) => {
+        assert(s._type !== 'UnionConditionalSpreadSelection');
+        if (s._type === 'TypenameField') {
+            typenameSelections.push(s);
+            return [];
+        }
+        if (s._type === 'ObjectConditionalSpreadSelection')
+            return [s];
+        const fragmentSpec = schema.client.fragments[s.fragment].spec;
+        assert(fragmentSpec._type === 'UnionFragmentSpec');
+        const [selections, tSelections] = resolveUnionSelections(schema, fragmentSpec.selections);
+        typenameSelections.push(...tSelections);
+        return selections;
+    })
+        .flat();
+    return [objectSelections, typenameSelections];
+}

package/actors/ts/graphql/generators/client/main.d.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript';
 import { ActorContext } from '../../../../../config.js';
-import { GraphqlActorConfig } from '../../actor.js';
-export declare function generateClientNodes(config: GraphqlActorConfig, context: ActorContext): ts.Node[];
+import ts from 'typescript';
+import { Config } from '../../actor.js';
+export declare function generateClientNodes(config: Config, context: ActorContext): ts.Node[];

package/actors/ts/graphql/generators/client/main.js

@@ -1,25 +1,9 @@
-import ts from 'typescript';
-import { generateFragmentTypes } from './fragments.js';
-import { generateOperationsNodes } from './operations.js';
-const operationTypeNode = ts.factory.createInterfaceDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), 'Operation', [
-    ts.factory.createTypeParameterDeclaration(undefined, 'V'),
-    ts.factory.createTypeParameterDeclaration(undefined, 'R'),
-], [], [
-    ts.factory.createPropertySignature(undefined, 'name', undefined, ts.factory.createTypeReferenceNode('string')),
-    ts.factory.createPropertySignature(undefined, 'type', undefined, ts.factory.createUnionTypeNode(['QUERY', 'MUTATION', 'SUBSCRIPTION'].map((v) => ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(v))))),
-    ts.factory.createPropertySignature(undefined, 'document', undefined, ts.factory.createTypeReferenceNode('string')),
-    ts.factory.createPropertySignature(undefined, 'variablesSchema', undefined, ts.factory.createTypeReferenceNode('z.ZodType', [
-        ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
-        ts.factory.createTypeReferenceNode('V'),
-    ])),
-    ts.factory.createPropertySignature(undefined, 'resultSchema', undefined, ts.factory.createTypeReferenceNode('z.ZodType', [
-        ts.factory.createTypeReferenceNode('R'),
-    ])),
-]);
+import { generateFragmentTypes } from './fragments/index.js';
+import { generateOperationsNodes } from './operations/index.js';
 export function generateClientNodes(config, context) {
+    const lazyFragmentsSet = new Set();
     return [
-        operationTypeNode,
-        ...generateFragmentTypes(config.scalarsMapping, context.schema),
-        ...generateOperationsNodes(config.scalarsMapping, context.schema),
+        ...generateFragmentTypes(config.scalarsMapping, context.schema, lazyFragmentsSet),
+        ...generateOperationsNodes(config.clientTypeNameBuilders, config.scalarsMapping, context.schema, lazyFragmentsSet),
     ];
 }

package/actors/ts/graphql/generators/client/operations/index.d.ts

@@ -0,0 +1,8 @@
+import { ClientTypeNameBuilders } from '../../../../../../actors/ts/shared.js';
+import { operationSchema } from '../../../../../../schema/client/operation.js';
+import { RootSchema } from '../../../../../../schema/root.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../server/scalars/mapping.js';
+export declare function opTypeToName(type: z.infer<typeof operationSchema>['type']): string;
+export declare function generateOperationsNodes(clientTypeNameBuilders: ClientTypeNameBuilders, scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>): ts.Node[];

package/actors/ts/graphql/generators/client/operations/index.js

@@ -0,0 +1,33 @@
+import ts from 'typescript';
+import { generateSchemaName, generateZodInferInterfaceType, } from '../../server/shared.js';
+import { generateOperationZodInputSchema } from './input-schema.js';
+import { generateOperationNode } from './node.js';
+import { generateOperationZodOutputSchema } from './output-schema.js';
+export function opTypeToName(type) {
+    switch (type) {
+        case 'QUERY':
+            return 'Query';
+        case 'MUTATION':
+            return 'Mutation';
+        case 'SUBSCRIPTION':
+            return 'Subscription';
+    }
+}
+function generateOperationNodes(clientTypeNameBuilders, scalarsMapping, lazyFragmentsSet, schema, operation) {
+    const variablesName = clientTypeNameBuilders.variablesTypeName(operation.name);
+    const resultName = clientTypeNameBuilders.resultTypeName(operation.name);
+    return [
+        generateOperationZodInputSchema(scalarsMapping, operation, variablesName),
+        generateZodInferInterfaceType('input', variablesName, generateSchemaName(variablesName)),
+        ts.factory.createIdentifier('\n'),
+        generateOperationZodOutputSchema(scalarsMapping, schema, lazyFragmentsSet, operation, resultName),
+        generateZodInferInterfaceType('output', resultName, generateSchemaName(resultName)),
+        generateOperationNode(clientTypeNameBuilders, schema, operation),
+        ts.factory.createIdentifier('\n'),
+    ];
+}
+export function generateOperationsNodes(clientTypeNameBuilders, scalarsMapping, schema, lazyFragmentsSet) {
+    return Object.values(schema.client.operations)
+        .map((operation) => generateOperationNodes(clientTypeNameBuilders, scalarsMapping, lazyFragmentsSet, schema, operation))
+        .flat();
+}

package/actors/ts/graphql/generators/client/operations/input-schema.d.ts

@@ -0,0 +1,5 @@
+import { operationSchema } from '../../../../../../schema/client/operation.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../server/scalars/mapping.js';
+export declare function generateOperationZodInputSchema(scalarsMapping: ScalarsMapping, operation: z.infer<typeof operationSchema>, variablesName: string): ts.VariableStatement;

package/actors/ts/graphql/generators/client/operations/input-schema.js

@@ -0,0 +1,16 @@
+import ts from 'typescript';
+import { generateInputTypeDefinitionFields } from '../../server/inputs.js';
+import { generateSchemaName } from '../../server/shared.js';
+function parametersToFields(parameters) {
+    return Object.fromEntries(Object.keys(parameters).map((name) => [
+        name.slice(1),
+        parameters[name],
+    ]));
+}
+export function generateOperationZodInputSchema(scalarsMapping, operation, variablesName) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(variablesName)), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'object'), undefined, [
+            ts.factory.createObjectLiteralExpression(generateInputTypeDefinitionFields(scalarsMapping, parametersToFields(operation.parameters), true), true),
+        ])),
+    ], ts.NodeFlags.Const));
+}

package/actors/ts/graphql/generators/client/operations/node.d.ts

@@ -0,0 +1,6 @@
+import { ClientTypeNameBuilders } from '../../../../../../actors/ts/shared.js';
+import { operationSchema } from '../../../../../../schema/client/operation.js';
+import { RootSchema } from '../../../../../../schema/root.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+export declare function generateOperationNode(clientTypeNameBuilders: ClientTypeNameBuilders, schema: RootSchema, operation: z.infer<typeof operationSchema>): ts.VariableStatement;

package/actors/ts/graphql/generators/client/operations/node.js

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import { generateSchemaName } from '../../server/shared.js';
+import { extractFragmentSourceTextsInSpec } from '../fragments/spec/shared.js';
+function generateProperties(clientTypeNameBuilders, schema, operation) {
+    return [
+        ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(operation.name)),
+        ts.factory.createPropertyAssignment('type', ts.factory.createStringLiteral(operation.type)),
+        ts.factory.createPropertyAssignment('document', ts.factory.createStringLiteral([
+            operation.sourceText,
+            ...extractFragmentSourceTextsInSpec(schema, operation.fragmentSpec),
+        ].join(' '))),
+        ts.factory.createPropertyAssignment('variablesSchema', ts.factory.createIdentifier(generateSchemaName(clientTypeNameBuilders.variablesTypeName(operation.name)))),
+        ts.factory.createPropertyAssignment('resultSchema', ts.factory.createIdentifier(generateSchemaName(clientTypeNameBuilders.resultTypeName(operation.name)))),
+    ];
+}
+export function generateOperationNode(clientTypeNameBuilders, schema, operation) {
+    return ts.factory.createVariableStatement(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(clientTypeNameBuilders.operationTypeName(operation.name)), undefined, undefined, ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(generateProperties(clientTypeNameBuilders, schema, operation), true), ts.factory.createTypeReferenceNode('const'))),
+    ], ts.NodeFlags.Const));
+}

package/actors/ts/graphql/generators/client/operations/output-schema.d.ts

@@ -0,0 +1,6 @@
+import { operationSchema } from '../../../../../../schema/client/operation.js';
+import { RootSchema } from '../../../../../../schema/root.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
+import { ScalarsMapping } from '../../server/scalars/mapping.js';
+export declare function generateOperationZodOutputSchema(scalarsMapping: ScalarsMapping, schema: RootSchema, lazyFragmentsSet: Set<string>, operation: z.infer<typeof operationSchema>, resultName: string): ts.VariableStatement;

package/actors/ts/graphql/generators/client/operations/output-schema.js

@@ -0,0 +1,8 @@
+import ts from 'typescript';
+import { generateSchemaName } from '../../server/shared.js';
+import { generateZodFragmentSpecCallExpression } from '../fragments/spec/index.js';
+export function generateOperationZodOutputSchema(scalarsMapping, schema, lazyFragmentsSet, operation, resultName) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(resultName)), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, lazyFragmentsSet, operation.fragmentSpec, undefined, true)[0]),
+    ], ts.NodeFlags.Const));
+}

package/actors/ts/graphql/generators/main.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 import { ActorContext } from '../../../../config.js';
-import { GraphqlActorConfig } from '../actor.js';
-export declare function generateNodes(config: GraphqlActorConfig, context: ActorContext): ts.Node[];
+import { Config } from '../actor.js';
+export declare function generateNodes(config: Config, context: ActorContext): ts.Node[];

package/actors/ts/graphql/generators/main.js

@@ -3,7 +3,7 @@ import { generateServerNodes } from './server/main.js';
 import { generateClientNodes } from './client/main.js';
 export function generateNodes(config, context) {
     return [
-        ts.factory.createImportDeclaration([], ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+        ts.factory.createImportDeclaration([], ts.factory.createImportClause(undefined, undefined, ts.factory.createNamedImports([
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('z')),
         ])), ts.factory.createStringLiteral('zod/v4')),
         ...config.importDeclarations,

package/actors/ts/graphql/generators/server/inputs.d.ts

@@ -3,5 +3,5 @@ import ts from 'typescript';
 import { inputSchema } from '../../../../../schema/server.js';
 import { inputFieldSchema } from '../../../../../schema/shared.js';
 import { ScalarsMapping } from './scalars/index.js';
-export declare function generateInputTypeDefinitionFields(scalarsMapping: ScalarsMapping, fields: Record<string, z.infer<typeof inputFieldSchema>>): (ts.PropertyAssignment | ts.GetAccessorDeclaration)[];
+export declare function generateInputTypeDefinitionFields(scalarsMapping: ScalarsMapping, fields: Record<string, z.infer<typeof inputFieldSchema>>, insideLazy: boolean): (ts.PropertyAssignment | ts.GetAccessorDeclaration)[];
 export declare function generateInputTypeDefinitions(scalarsMapping: ScalarsMapping, input: z.infer<typeof inputSchema>): ts.Node[];