@vladimirdev635/gql-codegen 0.0.97 → 0.0.98

package/actors/ts/formatters/eslint/index.d.ts

@@ -1,2 +1,2 @@
-export type { LintResult, ESLintClass, ESLintClassConstructor, LoadESLintFuncType } from './types.js';
+export type { LintResult, ESLintClass, ESLintClassConstructor, LoadESLintFuncType, } from './types.js';
 export { buildESLintFormatter } from './formatter.js';

package/actors/ts/formatters/index.d.ts

@@ -1 +1,2 @@
 export * as eslint from './eslint/index.js';
+export * as oxfmt from './oxfmt/index.js';

package/actors/ts/formatters/index.js

@@ -1 +1,2 @@
 export * as eslint from './eslint/index.js';
+export * as oxfmt from './oxfmt/index.js';

package/actors/ts/formatters/oxfmt/formatter.d.ts

@@ -0,0 +1,3 @@
+import { Formatter } from '../../shared.js';
+import { FormatFunc } from './types.js';
+export declare function buildOxfmtFormatter<T>(formatFunc: FormatFunc<T>, options: T): Promise<Formatter>;

package/actors/ts/formatters/oxfmt/formatter.js

@@ -0,0 +1,20 @@
+export async function buildOxfmtFormatter(formatFunc, options) {
+    return async (code) => {
+        const result = await formatFunc('[buffer].ts', code, options);
+        for (const error of result.errors) {
+            if (error.codeframe !== null) {
+                console.error(error.codeframe);
+            }
+            else {
+                console.error(error.message);
+                if (error.helpMessage !== null) {
+                    console.error(error.message);
+                }
+            }
+        }
+        if (result.errors.length > 0) {
+            throw new Error('Oxfmt failed to format code');
+        }
+        return result.code;
+    };
+}

package/actors/ts/formatters/oxfmt/index.d.ts

@@ -0,0 +1,2 @@
+export type { ErrorLabel, OxcError, Severity, FormatResult, FormatFunc, } from './types.js';
+export { buildOxfmtFormatter } from './formatter.js';

package/actors/ts/formatters/oxfmt/index.js

@@ -0,0 +1 @@
+export { buildOxfmtFormatter } from './formatter.js';

package/actors/ts/formatters/oxfmt/types.d.ts

@@ -0,0 +1,20 @@
+export interface ErrorLabel {
+    message: string | null;
+    start: number;
+    end: number;
+}
+export interface OxcError {
+    severity: Severity;
+    message: string;
+    labels: Array<ErrorLabel>;
+    helpMessage: string | null;
+    codeframe: string | null;
+}
+export type Severity = 'Error' | 'Warning' | 'Advice';
+export interface FormatResult {
+    /** The formatted code. */
+    code: string;
+    /** Parse and format errors. */
+    errors: Array<OxcError>;
+}
+export type FormatFunc<T> = (filename: string, code: string, options: T) => Promise<FormatResult>;

package/actors/ts/formatters/oxfmt/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -7,5 +7,5 @@ async function gqlActor(config, context) {
     writeFileSync(config.outPath, code);
 }
 export function buildGQLClientActor(config) {
-    return context => gqlActor(config, context);
+    return (context) => gqlActor(config, context);
 }

package/actors/ts/gql-client/generators/main.js

@@ -3,38 +3,38 @@ function generateFunctionBlock(operationName, operationType, returnType) {
     const callArgs = [
         ts.factory.createIdentifier(operationName),
         ts.factory.createIdentifier('variables'),
-        ts.factory.createIdentifier('requestContext')
+        ts.factory.createIdentifier('requestContext'),
     ];
     if (operationType === 'SUBSCRIPTION') {
         callArgs.push(ts.factory.createIdentifier('controller'));
     }
-    const awaitExpression = ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('executor'), operationType === 'SUBSCRIPTION' ?
-        'executeSubscription' :
-        'executeSync'), undefined, callArgs));
+    const awaitExpression = ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('executor'), operationType === 'SUBSCRIPTION'
+        ? 'executeSubscription'
+        : 'executeSync'), undefined, callArgs));
     if (returnType === 'ExecuteResult') {
-        return ts.factory.createBlock([
-            ts.factory.createReturnStatement(awaitExpression)
-        ], true);
+        return ts.factory.createBlock([ts.factory.createReturnStatement(awaitExpression)], true);
     }
     return ts.factory.createBlock([
         ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
             ts.factory.createVariableDeclaration('executorResult', undefined, undefined, awaitExpression),
         ], ts.NodeFlags.Const)),
-        ts.factory.createReturnStatement(ts.factory.createPropertyAccessChain(ts.factory.createIdentifier('executorResult'), undefined, 'result'))
+        ts.factory.createReturnStatement(ts.factory.createPropertyAccessChain(ts.factory.createIdentifier('executorResult'), undefined, 'result')),
     ], true);
 }
 function createReturnTypeNode(resultName, returnType, operationType) {
     const rOpType = ts.factory.createTypeReferenceNode(resultName);
-    const rType = operationType === 'SUBSCRIPTION' ?
-        ts.factory.createTypeReferenceNode('SubOpAsyncIterable', [rOpType]) :
-        rOpType;
+    const rType = operationType === 'SUBSCRIPTION'
+        ? ts.factory.createTypeReferenceNode('SubOpAsyncIterable', [
+            rOpType,
+        ])
+        : rOpType;
     if (returnType === 'ExecuteResult.result')
         return rType;
     return ts.factory.createTypeReferenceNode('ExecuteResult', [rType]);
 }
 function getReturnTypeFromConfig(config, operationName) {
-    return config.sdk.operationReturnTypeMapping[operationName] ||
-        config.sdk.defaultOperationReturnType;
+    return (config.sdk.operationReturnTypeMapping[operationName] ||
+        config.sdk.defaultOperationReturnType);
 }
 export function generateNodes(config, context) {
     const graphqlImports = [];
@@ -58,7 +58,7 @@ export function generateNodes(config, context) {
             funcArgs.push(ts.factory.createParameterDeclaration(undefined, undefined, 'controller', undefined, ts.factory.createTypeReferenceNode('AbortController')));
         }
         const propAssignment = ts.factory.createPropertyAssignment(operation.name, ts.factory.createArrowFunction(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Async), undefined, funcArgs, ts.factory.createTypeReferenceNode('Promise', [
-            createReturnTypeNode(resultName, returnType, operation.type)
+            createReturnTypeNode(resultName, returnType, operation.type),
         ]), ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), generateFunctionBlock(operationName, operation.type, returnType)));
         switch (operation.type) {
             case 'QUERY': {
@@ -77,7 +77,7 @@ export function generateNodes(config, context) {
     }
     const gqlClientImports = [
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('IExecutor')),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('RequestContext'))
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('RequestContext')),
     ];
     if (shouldIncludeExecuteResultType) {
         gqlClientImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('ExecuteResult')));
@@ -97,12 +97,16 @@ export function generateNodes(config, context) {
         ts.factory.createIdentifier('// @ts-nocheck'),
         ...config.importDeclarations,
         ts.factory.createImportDeclaration([], ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports(gqlClientImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client/types')),
-        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(graphqlImports.map(i => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(config.graphqlModulePath)),
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(graphqlImports.map((i) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(config.graphqlModulePath)),
         ts.factory.createIdentifier('\n'),
-        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext'))], [ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
-                ts.factory.createTypeReferenceNode('TRequestContext')
-            ]))], undefined, ts.factory.createBlock([
-            ts.factory.createReturnStatement(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(returnObjectNodes, true), ts.factory.createTypeReferenceNode('const')))
-        ], true))
+        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [
+            ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext')),
+        ], [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
+                ts.factory.createTypeReferenceNode('TRequestContext'),
+            ])),
+        ], undefined, ts.factory.createBlock([
+            ts.factory.createReturnStatement(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(returnObjectNodes, true), ts.factory.createTypeReferenceNode('const'))),
+        ], true)),
     ];
 }

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

@@ -1 +1 @@
-export { type OperationReturnType, type SDKConfig, type GQLClientActorConfig, buildGQLClientActor } from './actor.js';
+export { type OperationReturnType, type SDKConfig, type GQLClientActorConfig, buildGQLClientActor, } from './actor.js';

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

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

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

@@ -7,5 +7,5 @@ async function gqlClientReactActor(config, context) {
     writeFileSync(config.outPath, code);
 }
 export function buildGQLClientReactActor(config) {
-    return context => gqlClientReactActor(config, context);
+    return (context) => gqlClientReactActor(config, context);
 }

package/actors/ts/gql-client-react/generators/main.js

@@ -6,19 +6,19 @@ function generateFunctionBlock(operationName, type) {
                 ts.factory.createIdentifier('executor'),
                 ts.factory.createIdentifier(operationName),
                 ts.factory.createIdentifier('variables'),
-                ts.factory.createIdentifier('requestContext')
+                ts.factory.createIdentifier('requestContext'),
             ]);
         case 'LAZY':
             return ts.factory.createCallExpression(ts.factory.createIdentifier('useLazyOperation'), undefined, [
                 ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName)
+                ts.factory.createIdentifier(operationName),
             ]);
         case 'SUBSCRIPTION':
             return ts.factory.createCallExpression(ts.factory.createIdentifier('useSubscription'), undefined, [
                 ts.factory.createIdentifier('executor'),
                 ts.factory.createIdentifier(operationName),
                 ts.factory.createIdentifier('variables'),
-                ts.factory.createIdentifier('requestContext')
+                ts.factory.createIdentifier('requestContext'),
             ]);
     }
 }
@@ -30,19 +30,21 @@ function generateArrowFunction(operationName, variablesName, resultName, type) {
             resultType = ts.factory.createTypeReferenceNode('UseLazyOperationReturnType', [
                 ts.factory.createTypeReferenceNode(variablesName),
                 ts.factory.createTypeReferenceNode(resultName),
-                ts.factory.createTypeReferenceNode('TRequestContext')
+                ts.factory.createTypeReferenceNode('TRequestContext'),
             ]);
             break;
         case 'SYNC': {
             resultType = ts.factory.createTypeReferenceNode('OperationState', [
-                ts.factory.createTypeReferenceNode(resultName)
+                ts.factory.createTypeReferenceNode(resultName),
             ]);
             parameters.push(ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, ts.factory.createTypeReferenceNode(variablesName)), ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')));
             break;
         }
         case 'SUBSCRIPTION': {
             resultType = ts.factory.createTypeReferenceNode('OperationState', [
-                ts.factory.createTypeReferenceNode('SubOpAsyncIterable', [ts.factory.createTypeReferenceNode(resultName)])
+                ts.factory.createTypeReferenceNode('SubOpAsyncIterable', [
+                    ts.factory.createTypeReferenceNode(resultName),
+                ]),
             ]);
             parameters.push(ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, ts.factory.createTypeReferenceNode(variablesName)), ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')));
             break;
@@ -79,11 +81,11 @@ export function generateNodes(config, context) {
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useOperation')),
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useLazyOperation')),
         ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('OperationState')),
-        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseLazyOperationReturnType'))
+        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseLazyOperationReturnType')),
     ];
     const gqlClientImports = [
         ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('IExecutor')),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('RequestContext'))
+        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('RequestContext')),
     ];
     if (subscriptionNodes.length !== 0) {
         gqlClientReactImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useSubscription')));
@@ -104,12 +106,16 @@ export function generateNodes(config, context) {
         ...config.importDeclarations,
         ts.factory.createImportDeclaration([], ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(gqlClientReactImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client-react')),
         ts.factory.createImportDeclaration([], ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports(gqlClientImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client/types')),
-        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(graphqlImports.map(i => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(config.graphqlModulePath)),
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(graphqlImports.map((i) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(config.graphqlModulePath)),
         ts.factory.createIdentifier('\n'),
-        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext'))], [ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
-                ts.factory.createTypeReferenceNode('TRequestContext')
-            ]))], undefined, ts.factory.createBlock([
-            ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(returnObjectNodes, true))
-        ], true))
+        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [
+            ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext')),
+        ], [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
+                ts.factory.createTypeReferenceNode('TRequestContext'),
+            ])),
+        ], undefined, ts.factory.createBlock([
+            ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(returnObjectNodes, true)),
+        ], true)),
     ];
 }

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

@@ -1 +1 @@
-export { type GQLClientReactActorConfig, buildGQLClientReactActor } from './actor.js';
+export { type GQLClientReactActorConfig, buildGQLClientReactActor, } from './actor.js';

package/actors/ts/gql-client-react/index.js

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

package/actors/ts/graphql/actor.js

@@ -7,5 +7,5 @@ async function graphqlActor(config, context) {
     writeFileSync(config.outPath, code);
 }
 export function buildGraphqlActor(config) {
-    return context => graphqlActor(config, context);
+    return (context) => graphqlActor(config, context);
 }

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

@@ -1,32 +1,35 @@
 /* eslint-disable max-lines */
 import ts from 'typescript';
-import { generateSchemaName, generateZodInferTypeAlias } from '../server/shared.js';
+import { generateSchemaName, generateZodInferTypeAlias, } from '../server/shared.js';
 import { generateZodObjectFieldSpec } from '../server/objects.js';
 import assert from 'assert';
 import { invokeMethod } from '../../../shared.js';
 export function extractFragmentNamesInSpec(schema, fragmentSpec) {
     if (fragmentSpec._type === 'UnionFragmentSpec') {
-        return fragmentSpec.selections.map((s) => {
+        return fragmentSpec.selections
+            .map((s) => {
             if (s._type === 'SpreadSelection') {
                 const fragment = schema.client.fragments[s.fragment];
                 return [
                     s.fragment,
-                    ...extractFragmentNamesInSpec(schema, fragment.spec)
+                    ...extractFragmentNamesInSpec(schema, fragment.spec),
                 ];
             }
             if (s._type === 'ObjectConditionalSpreadSelection') {
                 return extractFragmentNamesInSpec(schema, s.spec);
             }
             return [];
-        }).flat();
+        })
+            .flat();
     }
-    return fragmentSpec.selections.map((s) => {
+    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)
+                ...extractFragmentNamesInSpec(schema, fragment.spec),
             ];
         }
         if (s._type === 'FieldSelection' && s.selection != null) {
@@ -34,17 +37,19 @@ export function extractFragmentNamesInSpec(schema, fragmentSpec) {
             return extractFragmentNamesInSpec(schema, s.selection);
         }
         return [];
-    }).flat();
+    })
+        .flat();
 }
 export function extractFragmentSourceTextsInSpec(schema, fragmentSpec) {
-    return Array.from(new Set(extractFragmentNamesInSpec(schema, fragmentSpec)))
-        .map(f => schema.client.fragments[f].sourceText);
+    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([
+    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));
+            ...extractFragmentSourceTextsInSpec(schema, fragment.spec),
+        ].join(' '))),
+    ], ts.NodeFlags.Const));
 }
 function generateZodObjectSelection(scalarsMapping, schema, objectType, selection, typenameConfig) {
     switch (selection._type) {
@@ -65,13 +70,13 @@ function generateZodObjectSelection(scalarsMapping, schema, objectType, selectio
             }
             else {
                 const optional = fieldSpec.spec._type !== 'callable' ||
-                    !selection.selection.selections.every(s => s._type === 'TypenameField') ||
+                    !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 });
                 if (fieldSpec.spec._type === 'array' ||
-                    fieldSpec.spec._type === 'callable' &&
-                        fieldSpec.spec.returnType._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]);
                 }
             }
@@ -87,11 +92,13 @@ function generateZodObjectSelection(scalarsMapping, schema, objectType, selectio
 }
 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))];
+    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');
+    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 });
@@ -104,17 +111,24 @@ function resolveSelections(specSelections, typenameConfig) {
 }
 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)]);
+    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');
+    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)]);
+    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 => {
+    const objectSelections = specSelections
+        .map((s) => {
         assert(s._type !== 'UnionConditionalSpreadSelection');
         if (s._type === 'TypenameField') {
             typenameSelections.push(s);
@@ -127,26 +141,31 @@ function resolveUnionSelections(schema, specSelections) {
         const [selections, tSelections] = resolveUnionSelections(schema, fragmentSpec.selections);
         typenameSelections.push(...tSelections);
         return selections;
-    }).flat();
+    })
+        .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.name].items)) {
-        if (!objectSelections.some(s => s.object === item)) {
+        if (!objectSelections.some((s) => s.object === item)) {
             objectSelections.push({
                 _type: 'ObjectConditionalSpreadSelection',
                 object: item,
                 spec: {
                     _type: 'ObjectFragmentSpec',
                     name: item,
-                    selections: []
-                }
+                    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)]);
+    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, typenameConfig) {
     if (spec._type === 'ObjectFragmentSpec') {
@@ -155,19 +174,22 @@ export function generateZodFragmentSpecCallExpression(scalarsMapping, schema, sp
     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));
+    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),
-        generateZodInferTypeAlias('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();
+    })
+        .flat();
 }

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

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

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

@@ -1,38 +1,52 @@
 /* eslint-disable max-lines */
 import ts from 'typescript';
 import { extractFragmentSourceTextsInSpec, generateZodFragmentSpecCallExpression, } from './fragments.js';
-import { generateSchemaName, generateZodInferTypeAlias } from '../server/shared.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';
+        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]]));
+    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([
+    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('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)
+                ...extractFragmentSourceTextsInSpec(schema, operation.fragmentSpec),
             ].join(' '))),
             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.factory.createTypeReferenceNode(operation.name + 'Variables'),
             ts.factory.createTypeReferenceNode(operation.name + 'Result'),
-        ])))], ts.NodeFlags.Const));
+        ]))),
+    ], 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));
+    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));
+    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 [
@@ -42,11 +56,13 @@ function generateOperationNodes(scalarsMapping, schema, operation) {
         genearteOperationZodOutputSchema(scalarsMapping, schema, operation),
         generateZodInferTypeAlias('output', operation.name + 'Result', generateSchemaName(operation.name + 'Result')),
         generateOperationNode(schema, operation),
-        ts.factory.createIdentifier('\n')
+        ts.factory.createIdentifier('\n'),
     ];
 }
 export function generateOperationsNodes(scalarsMapping, schema) {
-    return Object.values(schema.client.operations).map(operation => {
+    return Object.values(schema.client.operations)
+        .map((operation) => {
         return generateOperationNodes(scalarsMapping, schema, operation);
-    }).flat();
+    })
+        .flat();
 }

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

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