@vladimirdev635/gql-codegen 0.0.110 → 0.0.112

package/actors/text-diff.d.ts

@@ -0,0 +1,2 @@
+import { Change } from 'diff';
+export declare function printChanges(changes: Change[]): void;

package/actors/text-diff.js

@@ -0,0 +1,113 @@
+import pc from 'picocolors';
+var LineType;
+(function (LineType) {
+    LineType[LineType["Added"] = 0] = "Added";
+    LineType[LineType["Removed"] = 1] = "Removed";
+    LineType[LineType["Unchanged"] = 2] = "Unchanged";
+})(LineType || (LineType = {}));
+function buildLineNumbersString(newLineNumber, oldLineNumber, lineType) {
+    switch (lineType) {
+        case LineType.Added: {
+            const newStr = String(newLineNumber);
+            const oldStr = ' '.repeat(newStr.length);
+            return pc.green('+ ' + oldStr + ' ' + newStr);
+        }
+        case LineType.Removed: {
+            const oldStr = String(oldLineNumber);
+            const newStr = ' '.repeat(oldStr.length);
+            return pc.red('- ' + oldStr + ' ' + newStr);
+        }
+        case LineType.Unchanged: {
+            const oldStr = String(oldLineNumber);
+            const newStr = String(newLineNumber);
+            return pc.dim('  ' + oldStr + ' ' + newStr);
+        }
+    }
+}
+function getColorFunc(lineType) {
+    switch (lineType) {
+        case LineType.Added:
+            return pc.green;
+        case LineType.Removed:
+            return pc.red;
+        case LineType.Unchanged:
+            return pc.white;
+    }
+}
+function formatPrefix(newLineNumber, oldLineNumber, lineType) {
+    const colorFunc = getColorFunc(lineType);
+    return (buildLineNumbersString(newLineNumber, oldLineNumber, lineType) +
+        ' ' +
+        colorFunc('|'));
+}
+function formatLine(newLineNumber, oldLineNumber, lineType, line) {
+    const colorFunc = getColorFunc(lineType);
+    return (formatPrefix(newLineNumber, oldLineNumber, lineType) +
+        colorFunc(' ' + line));
+}
+function buildSeparatorLine(newLineNumber, oldLineNumber) {
+    return pc
+        .blue('-')
+        .repeat(2 +
+        String(newLineNumber).length +
+        1 +
+        String(oldLineNumber).length +
+        2);
+}
+const n = 10;
+function printLine(state, part, line) {
+    if (part.added) {
+        if (state.beforeBufferList.length !== 0) {
+            process.stdout.write(buildSeparatorLine(state.newLineNumber, state.oldLineNumber) +
+                '\n');
+            process.stdout.write(state.beforeBufferList.join('\n') + '\n');
+            state.beforeBufferList = [];
+        }
+        state.nextN = n;
+        process.stdout.write(formatLine(state.newLineNumber, state.oldLineNumber, LineType.Added, line) + '\n');
+        state.newLineNumber++;
+    }
+    else if (part.removed) {
+        if (state.beforeBufferList.length !== 0) {
+            process.stdout.write(buildSeparatorLine(state.newLineNumber, state.oldLineNumber) +
+                '\n');
+            process.stdout.write(state.beforeBufferList.join('\n') + '\n');
+            state.beforeBufferList = [];
+        }
+        state.nextN = n;
+        process.stdout.write(formatLine(state.newLineNumber, state.oldLineNumber, LineType.Removed, line) + '\n');
+        state.oldLineNumber++;
+    }
+    else {
+        const formattedLine = formatLine(state.newLineNumber, state.oldLineNumber, LineType.Unchanged, line);
+        if (state.nextN !== 0) {
+            process.stdout.write(formattedLine + '\n');
+            state.nextN -= 1;
+        }
+        else {
+            if (state.beforeBufferList.length < n) {
+                state.beforeBufferList.push(formattedLine);
+            }
+            else {
+                state.beforeBufferList.shift();
+                state.beforeBufferList.push(formattedLine);
+            }
+        }
+        state.oldLineNumber++;
+        state.newLineNumber++;
+    }
+}
+export function printChanges(changes) {
+    let state = {
+        oldLineNumber: 1,
+        newLineNumber: 1,
+        beforeBufferList: [],
+        nextN: 0,
+    };
+    for (const part of changes) {
+        const lines = part.value.replace(/\n$/, '').split('\n');
+        for (const line of lines) {
+            printLine(state, part, line);
+        }
+    }
+}

package/actors/ts/gql-client/actor.d.ts

@@ -1,8 +1,8 @@
+import { Actor, ActorContext } from '../../../config.js';
+import { OperationType } from '../../../schema/client/operation.js';
 import { PathOrFileDescriptor } from 'fs';
 import ts from 'typescript';
-import { Actor, ActorContext } from '../../../config.js';
 import { ClientTypeNameBuilders, TSActorConfig } from '../shared.js';
-import { OperationType } from '../../../schema/client/operation.js';
 export type OperationReturnType = 'ExecuteResult' | 'ExecuteResult.result';
 export interface SDKConfig {
     defaultOperationReturnType: OperationReturnType;

package/actors/ts/gql-client/actor.js

@@ -1,11 +1,11 @@
-import { writeFileSync } from 'fs';
+import { executeRunAction } from '../../utils.js';
 import { renderNodes, } from '../shared.js';
 import { generateNodes } from './generators/main.js';
-async function actor(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 build(config) {
-    return (context) => actor(config, context);
+    return (context, action) => actor(config, context, action);
 }

package/actors/ts/gql-client-framework/actor.js

@@ -1,11 +1,11 @@
-import { writeFileSync } from 'fs';
+import { executeRunAction } from '../../utils.js';
 import { renderNodes, } from '../shared.js';
 import { generateNodes } from './generators/main.js';
-async function actor(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 build(config) {
-    return (context) => actor(config, context);
+    return (context, action) => actor(config, context, action);
 }

package/actors/ts/gql-client-react/actor.d.ts

@@ -1,8 +1,9 @@
 import { Actor, ActorContext } from '../../../config.js';
 import { Config as FrameworkConfig, SDKConfig as FrameworkSDKConfig } from '../gql-client-framework/index.js';
-export interface SDKConfig extends Omit<FrameworkSDKConfig, 'buildVariablesType'> {
+import { TSActorConfig } from '../shared.js';
+export interface SDKConfig extends Pick<FrameworkSDKConfig, 'typeName' | 'queriesKey' | 'mutationsKey' | 'subscriptionsKey' | 'clientTypeNameBuilders' | 'hookNameBuilders' | 'operationHooksTypeNameBuilder' | 'lazyHookBuilderName' | 'lazyHookTypeName' | 'syncHookBuilderName' | 'syncHookTypeName' | 'subscriptionHookBuilderName' | 'subscriptionHookTypeName'> {
 }
-export interface Config extends Omit<FrameworkConfig, 'frameworkImportName' | 'sdk'> {
+export interface Config extends Pick<FrameworkConfig, 'outPath' | 'importDeclarations' | 'graphqlModulePath' | keyof TSActorConfig> {
     sdk: SDKConfig;
 }
 export declare function build(config: Config): Actor<ActorContext>;

package/actors/ts/gql-client-vue/actor.d.ts

@@ -1,8 +1,9 @@
 import { Actor, ActorContext } from '../../../config.js';
 import { Config as FrameworkConfig, SDKConfig as FrameworkSDKConfig } from '../gql-client-framework/index.js';
-export interface SDKConfig extends Omit<FrameworkSDKConfig, 'buildVariablesType'> {
+import { TSActorConfig } from '../shared.js';
+export interface SDKConfig extends Pick<FrameworkSDKConfig, 'typeName' | 'queriesKey' | 'mutationsKey' | 'subscriptionsKey' | 'clientTypeNameBuilders' | 'hookNameBuilders' | 'operationHooksTypeNameBuilder' | 'lazyHookBuilderName' | 'lazyHookTypeName' | 'syncHookBuilderName' | 'syncHookTypeName' | 'subscriptionHookBuilderName' | 'subscriptionHookTypeName'> {
 }
-export interface Config extends Omit<FrameworkConfig, 'frameworkImportName' | 'sdk'> {
+export interface Config extends Pick<FrameworkConfig, 'outPath' | 'importDeclarations' | 'graphqlModulePath' | keyof TSActorConfig> {
     sdk: SDKConfig;
 }
 export declare function build(config: Config): Actor<ActorContext>;

package/actors/ts/gql-client-vue/actor.js

@@ -1,5 +1,5 @@
-import { build as frameworkBuild, } from '../gql-client-framework/index.js';
 import ts from 'typescript';
+import { build as frameworkBuild, } from '../gql-client-framework/index.js';
 export function build(config) {
     return frameworkBuild({
         ...config,

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

@@ -1,6 +1,6 @@
-import { Actor, ActorContext } from '../../../config.js';
 import { PathOrFileDescriptor } from 'fs';
 import ts from 'typescript';
+import { Actor, ActorContext } from '../../../config.js';
 import { ClientTypeNameBuilders, TSActorConfig } from '../shared.js';
 import { ScalarsMapping } from './generators/server/scalars/index.js';
 export interface Config extends TSActorConfig {

package/actors/ts/graphql/actor.js

@@ -1,11 +1,11 @@
-import { writeFileSync } from 'fs';
 import { renderNodes, } from '../shared.js';
+import { executeRunAction } from '../../utils.js';
 import { generateNodes } from './generators/main.js';
-async function actor(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 build(config) {
-    return (context) => actor(config, context);
+    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 { FragmentSpecSchemaType, objectSelection } 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 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], insideLazy?: boolean): 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.js

@@ -1,8 +1,9 @@
-import { generateFragmentTypes } from './fragments.js';
-import { generateOperationsNodes } from './operations.js';
+import { generateFragmentTypes } from './fragments/index.js';
+import { generateOperationsNodes } from './operations/index.js';
 export function generateClientNodes(config, context) {
+    const lazyFragmentsSet = new Set();
     return [
-        ...generateFragmentTypes(config.scalarsMapping, context.schema),
-        ...generateOperationsNodes(config.clientTypeNameBuilders, 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/utils.d.ts

@@ -0,0 +1,3 @@
+import fs from 'fs';
+import { RunAction } from '../config.js';
+export declare function executeRunAction(outPath: fs.PathOrFileDescriptor, action: RunAction, code: string): void;

package/actors/utils.js

@@ -0,0 +1,22 @@
+import path from 'path';
+import fs from 'fs';
+import pc from 'picocolors';
+import { RunAction } from '../config.js';
+import { diffLines } from 'diff';
+import { printChanges } from './text-diff.js';
+export function executeRunAction(outPath, action, code) {
+    switch (action) {
+        case RunAction.Generate: {
+            fs.writeFileSync(outPath, code);
+            break;
+        }
+        case RunAction.Validate: {
+            const fileCode = fs.readFileSync(outPath).toString();
+            if (fileCode !== code) {
+                const changes = diffLines(fileCode, code);
+                process.stdout.write(pc.blue(`${path.relative(process.cwd(), outPath.toString())}:\n`));
+                printChanges(changes);
+            }
+        }
+    }
+}

package/config.d.ts

@@ -2,7 +2,12 @@ import { RootSchema } from './schema/root.js';
 export interface ActorContext {
     readonly schema: RootSchema;
 }
-export type Actor<T extends ActorContext> = (c: T) => Promise<void> | void;
+export declare enum RunAction {
+    Generate = 0,
+    Validate = 1
+}
+export declare function runActionFromArgv(argv: string[]): RunAction;
+export type Actor<T extends ActorContext> = (c: T, action: RunAction) => Promise<void> | void;
 export interface Config<T extends ActorContext> {
     context: T;
     actors: Actor<T>[];

package/config.js

@@ -1 +1,18 @@
-export {};
+export var RunAction;
+(function (RunAction) {
+    RunAction[RunAction["Generate"] = 0] = "Generate";
+    RunAction[RunAction["Validate"] = 1] = "Validate";
+})(RunAction || (RunAction = {}));
+export function runActionFromArgv(argv) {
+    if (argv.length < 3) {
+        throw new Error('argv length is less than 3, action is not provided, valid actions are: "generate" and "validate"');
+    }
+    switch (argv[2]) {
+        case 'validate':
+            return RunAction.Validate;
+        case 'generate':
+            return RunAction.Generate;
+        default:
+            throw new Error(`Unknown action: ${argv[2]}`);
+    }
+}

package/index.d.ts

@@ -1,4 +1,4 @@
-export { Actor, ActorContext, Config } from './config.js';
+export { type Actor, type ActorContext, type Config, type RunAction, runActionFromArgv, } from './config.js';
 export { run } from './main.js';
 export { loadClientSchemaFromFile, loadServerSchemaFromFile, loadRootSchemaFromGQLSubprocess, } from './schema/utils.js';
 export * as actors from './actors/index.js';

package/index.js

@@ -1,3 +1,4 @@
+export { runActionFromArgv, } from './config.js';
 export { run } from './main.js';
 export { loadClientSchemaFromFile, loadServerSchemaFromFile, loadRootSchemaFromGQLSubprocess, } from './schema/utils.js';
 export * as actors from './actors/index.js';

package/main.d.ts

@@ -1,2 +1,2 @@
-import { ActorContext, Config } from './config.js';
-export declare function run<TContext extends ActorContext>(config: Config<TContext>): Promise<void>;
+import { ActorContext, Config, RunAction } from './config.js';
+export declare function run<TContext extends ActorContext>(config: Config<TContext>, action: RunAction): Promise<void>;

package/main.js

@@ -1,5 +1,5 @@
-export async function run(config) {
+export async function run(config, action) {
     for (const actor of config.actors) {
-        await actor(config.context);
+        await actor(config.context, action);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vladimirdev635/gql-codegen",
-    "version": "0.0.110",
+    "version": "0.0.112",
     "description": "",
     "keywords": [],
     "homepage": "https://github.com/Voldemat/graphql-plus-plus#readme",
@@ -25,6 +25,10 @@
         "test": "vitest",
         "build": "tsc && tsc-alias && cp package.json ./dist/package.json"
     },
+    "dependencies": {
+        "diff": "^9.0.0",
+        "picocolors": "^1.1.1"
+    },
     "devDependencies": {
         "@types/node": "^24.0.1",
         "assert": "^2.1.0",

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

@@ -1,198 +0,0 @@
-import assert from 'assert';
-import ts from 'typescript';
-import { invokeMethod } from '../../../shared.js';
-import { generateZodObjectFieldSpec } from '../server/objects.js';
-import { generateSchemaName, generateZodInferInterfaceType, generateZodInferTypeAlias, } from '../server/shared.js';
-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);
-}
-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));
-}
-function generateZodObjectSelection(scalarsMapping, schema, objectType, selection, insideLazy, 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 {
-                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, 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);
-        }
-        case 'SpreadSelection': {
-            const schemaName = generateSchemaName(selection.fragment + 'Fragment');
-            const expressionForShape = insideLazy
-                ? ts.factory.createIdentifier(schemaName)
-                : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('lazy')), undefined, [
-                    ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind
-                        .EqualsGreaterThanToken), ts.factory.createIdentifier(schemaName)),
-                ]), ts.factory.createIdentifier('def')), ts.factory.createIdentifier('getter')), undefined, []);
-            return ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(expressionForShape, ts.factory.createIdentifier('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, insideLazy, typenameConfig))
-            .filter((s) => s !== null), true),
-    ]);
-    return 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 === 'UnionFragmentSpec');
-        const [selections, tSelections] = resolveUnionSelections(schema, fragmentSpec.selections);
-        typenameSelections.push(...tSelections);
-        return selections;
-    })
-        .flat();
-    return [objectSelections, typenameSelections];
-}
-function generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, 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: [],
-                },
-            });
-        }
-    }
-    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),
-    ]);
-    if (insideLazy)
-        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),
-    ]);
-}
-export function generateZodFragmentSpecCallExpression(scalarsMapping, schema, spec, typenameConfig, insideLazy = false) {
-    if (spec._type === 'ObjectFragmentSpec') {
-        return generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[spec.name], spec.selections, insideLazy, typenameConfig || { ensurePresent: true, optional: true });
-    }
-    return generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec, insideLazy);
-}
-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) {
-    const fName = fragmentName + 'Fragment';
-    return [
-        generateFragmentDocumentNode(schema, fragmentName, fragment),
-        generateZodFragmentSchema(scalarsMapping, schema, fragmentName, fragment),
-        fragment.spec._type === 'ObjectFragmentSpec'
-            ? generateZodInferInterfaceType('output', fName, generateSchemaName(fName))
-            : generateZodInferTypeAlias('output', fName, generateSchemaName(fName)),
-    ];
-}
-export function generateFragmentTypes(scalarsMapping, schema) {
-    return Object.entries(schema.client.fragments)
-        .map(([name, fragment]) => {
-        return generateFragmentSpecDeclarations(scalarsMapping, schema, name, fragment);
-    })
-        .flat();
-}

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

@@ -1,8 +0,0 @@
-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): ts.Node[];

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

@@ -1,66 +0,0 @@
-import ts from 'typescript';
-import { generateInputTypeDefinitionFields } from '../server/inputs.js';
-import { generateSchemaName, generateZodInferInterfaceType, } from '../server/shared.js';
-import { extractFragmentSourceTextsInSpec, generateZodFragmentSpecCallExpression, } from './fragments.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(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([
-            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)))),
-        ], true), ts.factory.createTypeReferenceNode('const'))),
-    ], ts.NodeFlags.Const));
-}
-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));
-}
-function genearteOperationZodOutputSchema(scalarsMapping, schema, 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, operation.fragmentSpec, undefined, true)),
-    ], ts.NodeFlags.Const));
-}
-function generateOperationNodes(clientTypeNameBuilders, scalarsMapping, 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'),
-        genearteOperationZodOutputSchema(scalarsMapping, schema, operation, resultName),
-        generateZodInferInterfaceType('output', resultName, generateSchemaName(resultName)),
-        generateOperationNode(clientTypeNameBuilders, schema, operation),
-        ts.factory.createIdentifier('\n'),
-    ];
-}
-export function generateOperationsNodes(clientTypeNameBuilders, scalarsMapping, schema) {
-    return Object.values(schema.client.operations)
-        .map((operation) => {
-        return generateOperationNodes(clientTypeNameBuilders, scalarsMapping, schema, operation);
-    })
-        .flat();
-}