@vladimirdev635/gql-codegen 0.0.11 → 0.0.13

package/dist/actors/ts/apollo/actor.d.ts

@@ -0,0 +1,12 @@
+import { PathOrFileDescriptor } from 'fs';
+import { Actor, ActorContext } from '@/config.js';
+import { TSActorConfig } from '../shared.js';
+export declare enum ImportModule {
+    GRAPHQL = 0,
+    APOLLO = 1
+}
+export interface ApolloActorConfig extends TSActorConfig {
+    outPath: PathOrFileDescriptor;
+    modulePaths: Record<ImportModule, string>;
+}
+export declare function buildApolloActor(config: ApolloActorConfig): Actor<ActorContext>;

package/dist/actors/ts/apollo/actor.js

@@ -0,0 +1,16 @@
+import { writeFileSync } from 'fs';
+import { renderNodes } from '../shared.js';
+import { generateNodes } from './generators/main.js';
+export var ImportModule;
+(function (ImportModule) {
+    ImportModule[ImportModule["GRAPHQL"] = 0] = "GRAPHQL";
+    ImportModule[ImportModule["APOLLO"] = 1] = "APOLLO";
+})(ImportModule || (ImportModule = {}));
+async function apolloActor(config, context) {
+    const nodes = generateNodes(config, context);
+    const code = await renderNodes(config, nodes);
+    writeFileSync(config.outPath, code);
+}
+export function buildApolloActor(config) {
+    return context => apolloActor(config, context);
+}

package/dist/actors/ts/apollo/generators/import-registry.d.ts

@@ -0,0 +1,14 @@
+import { ImportModule } from '../actor.js';
+import ts from 'typescript';
+interface ImportProps {
+    alias: string | null;
+    type: boolean;
+}
+export declare class ImportRegistry {
+    private imports;
+    generateImportDeclarations(modulePaths: Record<ImportModule, string>): ts.ImportDeclaration[];
+    addImport(module: ImportModule | string, name: string, props?: ImportProps): string;
+    addImports(module: ImportModule | string, imports: Record<string, ImportProps>): void;
+    private addToClause;
+}
+export {};

package/dist/actors/ts/apollo/generators/import-registry.js

@@ -0,0 +1,54 @@
+import { entries } from '../../../../utils.js';
+import { ImportModule } from '../actor.js';
+import ts from 'typescript';
+import assert from 'assert';
+export class ImportRegistry {
+    imports = {
+        [ImportModule.APOLLO]: { imports: {}, identifiers: new Set() },
+        [ImportModule.GRAPHQL]: { imports: {}, identifiers: new Set() }
+    };
+    generateImportDeclarations(modulePaths) {
+        return entries(this.imports)
+            .map(([module, clause]) => {
+            return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(entries(clause.imports)
+                .map(([name, props]) => ts.factory.createImportSpecifier(props.type, props.alias !== null ?
+                ts.factory.createIdentifier(props.alias) :
+                undefined, ts.factory.createIdentifier(name))))), ts.factory.createStringLiteral((module in modulePaths ?
+                modulePaths[module] :
+                module)));
+        });
+    }
+    addImport(module, name, props = { alias: null, type: true }) {
+        this.addImports(module, { [name]: props });
+        return props.alias || name;
+    }
+    addImports(module, imports) {
+        if (!(module in this.imports)) {
+            this.imports[module] = {
+                imports: {},
+                identifiers: new Set()
+            };
+        }
+        const clause = this.imports[module];
+        for (const [name, props] of Object.entries(imports)) {
+            if (name in clause.imports) {
+                if (clause.imports[name].alias === props.alias)
+                    continue;
+                this.addToClause(clause, name, props);
+                continue;
+            }
+            this.addToClause(clause, name, props);
+        }
+    }
+    addToClause(clause, name, props) {
+        if (props.alias === null) {
+            assert(!clause.identifiers.has(name));
+            clause.imports[name] = props;
+            clause.identifiers.add(name);
+            return;
+        }
+        assert(!clause.identifiers.has(props.alias));
+        clause.imports[name] = props;
+        clause.identifiers.add(props.alias);
+    }
+}

package/dist/actors/ts/apollo/generators/main.d.ts

@@ -0,0 +1,9 @@
+import { ActorContext } from '@/config.js';
+import { ApolloActorConfig } from '../actor.js';
+import ts from 'typescript';
+import { operationSchema } from '@/schema/client/operation.js';
+import { z } from 'zod/v4';
+import { ImportRegistry } from './import-registry.js';
+export declare function generateMutationFuncTypeNode(registry: ImportRegistry, operationName: string): ts.TypeAliasDeclaration;
+export declare function generateOperationNodes(registry: ImportRegistry, operation: z.infer<typeof operationSchema>): ts.Node[];
+export declare function generateNodes(config: ApolloActorConfig, context: ActorContext): ts.Node[];

package/dist/actors/ts/apollo/generators/main.js

@@ -0,0 +1,100 @@
+import { ImportModule } from '../actor.js';
+import ts from 'typescript';
+import { opTypeToName } from '../../graphql/generators/client/operations.js';
+import { addNewLineBetweenNodes } from '../../shared.js';
+import { ImportRegistry } from './import-registry.js';
+export function generateMutationFuncTypeNode(registry, operationName) {
+    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), operationName + 'MutationFn', [], ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.APOLLO, 'MutationFunction'), [
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operationName + 'Mutation')),
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operationName + 'MutationVariables'))
+    ]));
+}
+function generateOperationHookFunctionNodes(registry, operation, operationInfix) {
+    return [
+        ts.factory.createFunctionDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], undefined, ts.factory.createIdentifier('use' +
+            operation.name +
+            operationInfix +
+            opTypeToName(operation.type)), undefined, [ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('baseOptions'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(registry.addImport(ImportModule.APOLLO, opTypeToName(operation.type) + 'HookOptions')), [
+                ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name + opTypeToName(operation.type))),
+                ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name +
+                    opTypeToName(operation.type) +
+                    'Variables'))
+            ]), undefined)], undefined, ts.factory.createBlock([
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier('options'), undefined, undefined, ts.factory.createObjectLiteralExpression([
+                    ts.factory.createSpreadAssignment(ts.factory.createIdentifier('defaultOptions')),
+                    ts.factory.createSpreadAssignment(ts.factory.createIdentifier('baseOptions'))
+                ], false))], ts.NodeFlags.Const)),
+            ts.factory.createReturnStatement(ts.factory.createCallExpression(ts.factory.createIdentifier(registry.addImport(ImportModule.APOLLO, 'use' +
+                operationInfix +
+                opTypeToName(operation.type), { alias: null, type: false })), [
+                ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name +
+                    opTypeToName(operation.type))),
+                ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name +
+                    opTypeToName(operation.type) +
+                    'Variables'))
+            ], [
+                ts.factory.createIdentifier(operation.name + 'ApolloDocument'),
+                ts.factory.createIdentifier('options')
+            ]))
+        ], true)),
+        ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(operation.name +
+            opTypeToName(operation.type) +
+            operationInfix +
+            'HookResult'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('ReturnType'), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier('use' + operation.name + opTypeToName(operation.type)), undefined)]))
+    ];
+}
+function generateOperationDocumentNode(registry, operationName) {
+    return ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(operationName + 'ApolloDocument', undefined, undefined, ts.factory.createCallExpression(ts.factory.createIdentifier(registry.addImport(ImportModule.APOLLO, 'gql', { alias: null, type: false })), undefined, [ts.factory.createIdentifier(registry.addImport(ImportModule.GRAPHQL, operationName + 'Document', { alias: null, type: false }))]))], ts.NodeFlags.Const));
+}
+function generateQueryResultNode(registry, operation) {
+    const opName = opTypeToName(operation.type);
+    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), operation.name + opName + 'Result', [], ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.APOLLO, 'QueryResult'), [
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name + opName)),
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name + 'QueryVariables'))
+    ]));
+}
+function generateMutationOptionsNode(registry, operation) {
+    const opName = opTypeToName(operation.type);
+    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), operation.name + opName + 'Options', [], ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.APOLLO, 'BaseMutationOptions'), [
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name + opName)),
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name + opName + 'Variables'))
+    ]));
+}
+function generateMutationResultNode(registry, operation) {
+    const opName = opTypeToName(operation.type);
+    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), operation.name + opName + 'Result', [], ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.APOLLO, 'MutationResult'), [
+        ts.factory.createTypeReferenceNode(registry.addImport(ImportModule.GRAPHQL, operation.name + opName))
+    ]));
+}
+function generateOperationHookNodes(registry, operation) {
+    const nodes = [
+        generateOperationDocumentNode(registry, operation.name),
+        ...generateOperationHookFunctionNodes(registry, operation, '')
+    ];
+    if (operation.type === 'QUERY') {
+        nodes.push(...generateOperationHookFunctionNodes(registry, operation, 'Lazy'), ...generateOperationHookFunctionNodes(registry, operation, 'Suspense'), generateQueryResultNode(registry, operation));
+    }
+    if (operation.type === 'MUTATION') {
+        nodes.push(generateMutationResultNode(registry, operation), generateMutationOptionsNode(registry, operation));
+    }
+    return nodes;
+}
+export function generateOperationNodes(registry, operation) {
+    const nodes = [];
+    if (operation.type === 'MUTATION') {
+        nodes.push(generateMutationFuncTypeNode(registry, operation.name));
+    }
+    nodes.push(...generateOperationHookNodes(registry, operation));
+    return nodes;
+}
+export function generateNodes(config, context) {
+    const registry = new ImportRegistry();
+    const nodes = Object.values(context.schema.client.operations).map(op => {
+        return generateOperationNodes(registry, op);
+    }).flat();
+    return addNewLineBetweenNodes([
+        ...registry.generateImportDeclarations(config.modulePaths),
+        ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier('defaultOptions'), undefined, undefined, ts.factory.createObjectLiteralExpression())], ts.NodeFlags.Const)),
+        ...nodes
+    ]);
+}

package/dist/actors/ts/apollo/index.d.ts

@@ -0,0 +1 @@
+export { ApolloActorConfig, buildApolloActor } from './actor.js';

package/dist/actors/ts/apollo/index.js

@@ -0,0 +1 @@
+export { buildApolloActor } from './actor.js';

package/dist/actors/ts/graphql/actor.d.ts

@@ -0,0 +1,11 @@
+import { ScalarsMapping } from './generators/server/scalars/mapping.js';
+import { PathOrFileDescriptor } from 'fs';
+import ts from 'typescript';
+import { Actor, ActorContext } from '@/config.js';
+import { TSActorConfig } from '../shared.js';
+export interface GraphqlActorConfig extends TSActorConfig {
+    outPath: PathOrFileDescriptor;
+    scalarsMapping: ScalarsMapping;
+    importDeclarations: ts.ImportDeclaration[];
+}
+export declare function buildGraphqlActor(config: GraphqlActorConfig): Actor<ActorContext>;

package/dist/actors/ts/graphql/actor.js

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

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

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+import { RootSchema } from '@/schema/root.js';
+import { FragmentSpecSchemaType } from '@/schema/client/fragment.js';
+import { ScalarsMapping } from '../server/scalars/mapping.js';
+export declare function extractFragmentSourceTextsInSpec(schema: RootSchema, fragmentSpec: FragmentSpecSchemaType): string[];
+export declare function generateZodFragmentSpecCallExpression(scalarsMapping: ScalarsMapping, schema: RootSchema, spec: FragmentSpecSchemaType): ts.CallExpression;
+export declare function generateFragmentTypes(scalarsMapping: ScalarsMapping, schema: RootSchema): ts.Node[];

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

@@ -0,0 +1,146 @@
+/* eslint-disable max-lines */
+import ts from 'typescript';
+import { generateSchemaName } from '../server/shared.js';
+import { generateZodObjectFieldSpec } from '../server/objects.js';
+import assert from 'assert';
+import { invokeMethod } from '../../../shared.js';
+export function extractFragmentSourceTextsInSpec(schema, fragmentSpec) {
+    if (fragmentSpec._type === 'union') {
+        return fragmentSpec.selections.map((s) => {
+            if (s._type === 'SpreadSelection') {
+                return [schema.client.fragments[s.fragment].sourceText];
+            }
+            if (s._type === 'ObjectConditionalSpreadSelection') {
+                return extractFragmentSourceTextsInSpec(schema, s.spec);
+            }
+            return [];
+        }).flat();
+    }
+    return fragmentSpec.selections.map((s) => {
+        if (s._type === 'SpreadSelection') {
+            return [schema.client.fragments[s.fragment].sourceText];
+        }
+        if (s._type === 'FieldSelection' && s.selection !== null) {
+            return extractFragmentSourceTextsInSpec(schema, s.selection);
+        }
+        return [];
+    }).flat();
+}
+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('\n')))], ts.NodeFlags.Const));
+}
+function generateZodObjectSelection(scalarsMapping, schema, objectType, selection, typenameConfig) {
+    switch (selection._type) {
+        case 'TypenameField': {
+            if ('ignore' in typenameConfig)
+                return null;
+            let expression = invokeMethod(ts.factory.createIdentifier('z'), 'literal', [ts.factory.createStringLiteral(objectType.name)]);
+            if (selection.alias === null && typenameConfig.optional) {
+                expression = invokeMethod(invokeMethod(expression, 'nullable', []), 'optional', []);
+            }
+            return ts.factory.createPropertyAssignment(selection.alias || '__typename', expression);
+        }
+        case 'FieldSelection': {
+            const fieldSpec = objectType.fields[selection.name];
+            let expression;
+            if (selection.selection === null) {
+                expression = generateZodObjectFieldSpec(scalarsMapping, fieldSpec);
+            }
+            else {
+                // eslint-disable-next-line no-use-before-define
+                expression = generateZodFragmentSpecCallExpression(scalarsMapping, schema, selection.selection);
+            }
+            return ts.factory.createPropertyAssignment(selection.alias, expression);
+        }
+        case 'SpreadSelection': {
+            return ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(generateSchemaName(selection.fragment + 'Fragment')), 'shape'));
+        }
+    }
+}
+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;
+}
+function generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, object, specSelections, insideLazy, typenameConfig) {
+    const selections = resolveSelections(specSelections, typenameConfig);
+    const expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'object'), undefined, [ts.factory.createObjectLiteralExpression(selections.map(s => generateZodObjectSelection(scalarsMapping, schema, object, s, typenameConfig)).filter(s => s !== null), true)]);
+    if (insideLazy)
+        return expression;
+    const hasSpreadSelection = selections.some(s => s._type === 'SpreadSelection');
+    if (!hasSpreadSelection)
+        return expression;
+    return 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)]);
+}
+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 === 'union');
+        const [selections, tSelections] = resolveUnionSelections(schema, fragmentSpec.selections);
+        typenameSelections.push(...tSelections);
+        return selections;
+    }).flat();
+    return [objectSelections, typenameSelections];
+}
+function generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec) {
+    const [objectSelections, typenameSelections] = resolveUnionSelections(schema, spec.selections);
+    for (const item of Object.keys(schema.server.unions[spec.unionName].items)) {
+        if (!objectSelections.some(s => s.object === item)) {
+            objectSelections.push({
+                _type: 'ObjectConditionalSpreadSelection',
+                object: item,
+                spec: {
+                    _type: 'object',
+                    name: item,
+                    selections: []
+                }
+            });
+        }
+    }
+    const expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'union'), undefined, [ts.factory.createArrayLiteralExpression(objectSelections.map(s => generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[s.object], [...s.spec.selections, ...typenameSelections], true, { ensurePresent: true, optional: false })), true)]);
+    return 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)]);
+}
+export function generateZodFragmentSpecCallExpression(scalarsMapping, schema, spec) {
+    if (spec._type === 'object') {
+        return generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[spec.name], spec.selections, false, { ensurePresent: true, optional: true });
+    }
+    return generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec);
+}
+function generateZodFragmentSchema(scalarsMapping, schema, fragmentName, fragment) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(fragmentName + 'Fragment')), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, fragment.spec))], ts.NodeFlags.Const));
+}
+function generateFragmentSpecDeclarations(scalarsMapping, schema, fragmentName, fragment) {
+    return [
+        generateFragmentDocumentNode(schema, fragmentName, fragment),
+        generateZodFragmentSchema(scalarsMapping, schema, fragmentName, fragment)
+    ];
+}
+export function generateFragmentTypes(scalarsMapping, schema) {
+    return Object.entries(schema.client.fragments)
+        .map(([name, fragment]) => {
+        return generateFragmentSpecDeclarations(scalarsMapping, schema, name, fragment);
+    }).flat();
+}

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

@@ -0,0 +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[];

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

@@ -0,0 +1,15 @@
+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.createPropertySignature(undefined, 'document', undefined, ts.factory.createTypeReferenceNode('string')),
+    ts.factory.createPropertySignature(undefined, 'variablesSchema', undefined, ts.factory.createTypeReferenceNode('z.ZodType')),
+    ts.factory.createPropertySignature(undefined, 'resultSchema', undefined, ts.factory.createTypeReferenceNode('z.ZodType'))
+]);
+export function generateClientNodes(config, context) {
+    return [
+        operationTypeNode,
+        ...generateFragmentTypes(config.scalarsMapping, context.schema),
+        ...generateOperationsNodes(config.scalarsMapping, context.schema)
+    ];
+}

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

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+import { RootSchema } from '@/schema/root.js';
+import { operationSchema } from '@/schema/client/operation.js';
+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(scalarsMapping: ScalarsMapping, schema: RootSchema): ts.Node[];

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

@@ -0,0 +1,47 @@
+/* eslint-disable max-lines */
+import ts from 'typescript';
+import { extractFragmentSourceTextsInSpec, generateZodFragmentSpecCallExpression, } from './fragments.js';
+import { generateSchemaName, generateZodInferTypeAlias } from '../server/shared.js';
+import { generateInputTypeDefinitionFields } from '../server/inputs.js';
+export function opTypeToName(type) {
+    switch (type) {
+        case 'QUERY': return 'Query';
+        case 'MUTATION': return 'Mutation';
+        case 'SUBSCRIPTION': return 'Subscription';
+    }
+}
+function parametersToFields(parameters) {
+    return Object.fromEntries(Object.keys(parameters).map(name => [name.slice(1), parameters[name]]));
+}
+function generateOperationNode(schema, operation) {
+    return ts.factory.createVariableStatement(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(operation.name + 'Operation'), undefined, undefined, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('document', ts.factory.createStringLiteral([
+                operation.sourceText,
+                ...extractFragmentSourceTextsInSpec(schema, operation.fragmentSpec)
+            ].join('\n'))),
+            ts.factory.createPropertyAssignment('variablesSchema', ts.factory.createIdentifier(generateSchemaName(operation.name + 'Variables'))),
+            ts.factory.createPropertyAssignment('resultSchema', ts.factory.createIdentifier(generateSchemaName(operation.name + 'Result')))
+        ], true), ts.factory.createTypeReferenceNode('const')), ts.factory.createTypeReferenceNode('Operation')))], ts.NodeFlags.Const));
+}
+function generateOperationZodInputSchema(scalarsMapping, operation) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(operation.name + 'Variables')), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'object'), undefined, [ts.factory.createObjectLiteralExpression(generateInputTypeDefinitionFields(scalarsMapping, parametersToFields(operation.parameters)), true)]))], ts.NodeFlags.Const));
+}
+function genearteOperationZodOutputSchema(scalarsMapping, schema, operation) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(operation.name + 'Result')), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, operation.fragmentSpec))], ts.NodeFlags.Const));
+}
+function generateOperationNodes(scalarsMapping, schema, operation) {
+    return [
+        generateOperationZodInputSchema(scalarsMapping, operation),
+        generateZodInferTypeAlias(operation.name + 'Variables', generateSchemaName(operation.name + 'Variables')),
+        ts.factory.createIdentifier('\n'),
+        genearteOperationZodOutputSchema(scalarsMapping, schema, operation),
+        generateZodInferTypeAlias(operation.name + 'Result', generateSchemaName(operation.name + 'Result')),
+        generateOperationNode(schema, operation),
+        ts.factory.createIdentifier('\n')
+    ];
+}
+export function generateOperationsNodes(scalarsMapping, schema) {
+    return Object.values(schema.client.operations).map(operation => {
+        return generateOperationNodes(scalarsMapping, schema, operation);
+    }).flat();
+}

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

@@ -0,0 +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[];

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

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+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.createImportSpecifier(false, undefined, ts.factory.createIdentifier('z'))
+        ])), ts.factory.createStringLiteral('zod/v4')),
+        ...config.importDeclarations,
+        ts.factory.createIdentifier('\n'),
+        ...generateServerNodes(config, context),
+        ...generateClientNodes(config, context)
+    ];
+}

package/dist/actors/ts/graphql/generators/server/enums.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod/v4';
+import ts from 'typescript';
+import { enumSchema } from '@/schema/server.js';
+export declare function generateEnumDefinition(e: z.infer<typeof enumSchema>): ts.EnumDeclaration;

package/dist/actors/ts/graphql/generators/server/enums.js

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+export function generateEnumDefinition(e) {
+    return ts.factory.createEnumDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), e.name, e.values.map(value => ts.factory.createEnumMember(value)));
+}

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

@@ -0,0 +1,7 @@
+import { z } from 'zod/v4';
+import ts from 'typescript';
+import { inputSchema } from '@/schema/server.js';
+import { inputFieldSchema } from '@/schema/shared.js';
+import { ScalarsMapping } from './scalars/mapping.js';
+export declare function generateInputTypeDefinitionFields(scalarsMapping: ScalarsMapping, fields: Record<string, z.infer<typeof inputFieldSchema>>): ts.PropertyAssignment[];
+export declare function generateInputTypeDefinitions(scalarsMapping: ScalarsMapping, input: z.infer<typeof inputSchema>): ts.Node[];

package/dist/actors/ts/graphql/generators/server/inputs.js

@@ -0,0 +1,50 @@
+import ts from 'typescript';
+import { getScalarSpecFromMapping } from './scalars/mapping.js';
+import { invokeMethod } from '../../../shared.js';
+import { generateSchemaName, generateZodInferTypeAlias } from './shared.js';
+function generateZodInputTypeSpec(scalarsMapping, type) {
+    switch (type._type) {
+        case 'Enum': {
+            return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'enum'), undefined, [ts.factory.createIdentifier(type.name)]);
+        }
+        case 'Scalar': {
+            return getScalarSpecFromMapping(scalarsMapping, type.name).inputSchema;
+        }
+        case 'InputType': {
+            return ts.factory.createIdentifier(generateSchemaName(type.name));
+        }
+    }
+}
+function generateZodInputFieldSpec(scalarsMapping, field) {
+    let expression;
+    switch (field.spec._type) {
+        case 'array': {
+            expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'array'), undefined, [generateZodInputTypeSpec(scalarsMapping, field.spec.type)]);
+            break;
+        }
+        case 'literal': {
+            expression = generateZodInputTypeSpec(scalarsMapping, field.spec.type);
+        }
+    }
+    if (!field.nullable) {
+        return expression;
+    }
+    return invokeMethod(invokeMethod(expression, 'nullable', []), 'optional', []);
+}
+export function generateInputTypeDefinitionFields(scalarsMapping, fields) {
+    return Object.entries(fields).map(([name, field]) => {
+        return ts.factory.createPropertyAssignment(name, generateZodInputFieldSpec(scalarsMapping, field));
+    });
+}
+function generateZodInputTypeDefinition(scalarsMapping, name, fields) {
+    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(generateSchemaName(name), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('object')), undefined, [ts.factory.createObjectLiteralExpression(generateInputTypeDefinitionFields(scalarsMapping, fields), true)]))
+    ], ts.NodeFlags.Const));
+}
+export function generateInputTypeDefinitions(scalarsMapping, input) {
+    return [
+        generateZodInputTypeDefinition(scalarsMapping, input.name, input.fields),
+        generateZodInferTypeAlias(input.name, generateSchemaName(input.name)),
+        ts.factory.createIdentifier('\n')
+    ];
+}

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

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

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

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import { generateEnumDefinition } from './enums.js';
+import { generateUnionTypeDefinitions } from './unions.js';
+import { generateInputTypeDefinitions } from './inputs.js';
+import { addNewLineBetweenNodes } from '../../../shared.js';
+import { generateObjectTypeNodes } from './objects.js';
+export function generateServerNodes(config, context) {
+    return [
+        ...addNewLineBetweenNodes(Object.values(context.schema.server.enums)
+            .map(generateEnumDefinition)),
+        ts.factory.createIdentifier('\n'),
+        ...Object.values(context.schema.server.objects)
+            .map(object => generateObjectTypeNodes(config.scalarsMapping, object)).flat(),
+        ...Object.values(context.schema.server.unions)
+            .map(union => generateUnionTypeDefinitions(config.scalarsMapping, context.schema.server.objects, union)).flat(),
+        ...Object.values(context.schema.server.inputs)
+            .map(input => generateInputTypeDefinitions(config.scalarsMapping, input))
+            .flat()
+    ];
+}

package/dist/actors/ts/graphql/generators/server/objects.d.ts

@@ -0,0 +1,9 @@
+import { ScalarsMapping } from './scalars/mapping.js';
+import ts from 'typescript';
+import { objectFieldSchema, objectNonCallableFieldSpecSchema, objectSchema } from '@/schema/server.js';
+import { z } from 'zod/v4';
+export declare function generateObjectNonCallableFieldSpec(scalarsMapping: ScalarsMapping, spec: z.infer<typeof objectNonCallableFieldSpecSchema>): ts.Expression;
+export declare function generateZodObjectFieldSpec(scalarsMapping: ScalarsMapping, field: z.infer<typeof objectFieldSchema>): ts.Expression;
+export declare function generateZodObjectTypeExpression(scalarsMapping: ScalarsMapping, object: z.infer<typeof objectSchema>, includeTypename?: boolean): ts.CallExpression;
+export declare function generateZodObjectTypeNode(scalarsMapping: ScalarsMapping, object: z.infer<typeof objectSchema>): ts.VariableStatement;
+export declare function generateObjectTypeNodes(scalarsMapping: ScalarsMapping, object: z.infer<typeof objectSchema>): ts.Node[];