@vladimirdev635/gql-codegen 0.0.108 → 0.0.110

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

@@ -1,9 +1,8 @@
-/* eslint-disable max-lines */
-import ts from 'typescript';
-import { generateSchemaName, generateZodInferTypeAlias, } from '../server/shared.js';
-import { generateZodObjectFieldSpec } from '../server/objects.js';
 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
@@ -51,7 +50,7 @@ function generateFragmentDocumentNode(schema, name, fragment) {
         ].join(' '))),
     ], ts.NodeFlags.Const));
 }
-function generateZodObjectSelection(scalarsMapping, schema, objectType, selection, typenameConfig) {
+function generateZodObjectSelection(scalarsMapping, schema, objectType, selection, insideLazy, typenameConfig) {
     switch (selection._type) {
         case 'TypenameField': {
             if ('ignore' in typenameConfig)
@@ -73,7 +72,7 @@ function generateZodObjectSelection(scalarsMapping, schema, objectType, selectio
                     !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 });
+                expression = generateZodFragmentSpecCallExpression(scalarsMapping, schema, selection.selection, { ensurePresent: true, optional }, insideLazy);
                 if (fieldSpec.spec._type === 'array' ||
                     (fieldSpec.spec._type === 'callable' &&
                         fieldSpec.spec.returnType._type === 'array')) {
@@ -86,7 +85,14 @@ function generateZodObjectSelection(scalarsMapping, schema, objectType, selectio
             return ts.factory.createPropertyAssignment(selection.alias, expression);
         }
         case 'SpreadSelection': {
-            return ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(generateSchemaName(selection.fragment + 'Fragment')), 'shape'));
+            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')));
         }
     }
 }
@@ -113,17 +119,10 @@ function generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, obj
     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))
+            .map((s) => generateZodObjectSelection(scalarsMapping, schema, object, s, insideLazy, typenameConfig))
             .filter((s) => s !== null), true),
     ]);
-    if (insideLazy)
-        return expression;
-    const hasSpreadSelection = selections.some((s) => s._type === 'SpreadSelection');
-    if (!hasSpreadSelection)
-        return expression;
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'lazy'), undefined, [
-        ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expression),
-    ]);
+    return expression;
 }
 function resolveUnionSelections(schema, specSelections) {
     const typenameSelections = [];
@@ -145,7 +144,7 @@ function resolveUnionSelections(schema, specSelections) {
         .flat();
     return [objectSelections, typenameSelections];
 }
-function generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec) {
+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)) {
@@ -163,15 +162,17 @@ function generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec
     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) {
+export function generateZodFragmentSpecCallExpression(scalarsMapping, schema, spec, typenameConfig, insideLazy = false) {
     if (spec._type === 'ObjectFragmentSpec') {
-        return generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[spec.name], spec.selections, false, typenameConfig || { ensurePresent: true, optional: true });
+        return generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[spec.name], spec.selections, insideLazy, typenameConfig || { ensurePresent: true, optional: true });
     }
-    return generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec);
+    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([
@@ -183,7 +184,9 @@ function generateFragmentSpecDeclarations(scalarsMapping, schema, fragmentName,
     return [
         generateFragmentDocumentNode(schema, fragmentName, fragment),
         generateZodFragmentSchema(scalarsMapping, schema, fragmentName, fragment),
-        generateZodInferTypeAlias('output', fName, generateSchemaName(fName)),
+        fragment.spec._type === 'ObjectFragmentSpec'
+            ? generateZodInferInterfaceType('output', fName, generateSchemaName(fName))
+            : generateZodInferTypeAlias('output', fName, generateSchemaName(fName)),
     ];
 }
 export function generateFragmentTypes(scalarsMapping, schema) {

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

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

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

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

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

@@ -1,7 +1,8 @@
-import ts from 'typescript';
-import { RootSchema } from '../../../../../schema/root.js';
+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(scalarsMapping: ScalarsMapping, schema: RootSchema): ts.Node[];
+export declare function generateOperationsNodes(clientTypeNameBuilders: ClientTypeNameBuilders, scalarsMapping: ScalarsMapping, schema: RootSchema): ts.Node[];

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

@@ -1,8 +1,7 @@
-/* eslint-disable max-lines */
 import ts from 'typescript';
-import { extractFragmentSourceTextsInSpec, generateZodFragmentSpecCallExpression, } from './fragments.js';
-import { generateSchemaName, generateZodInferTypeAlias, } from '../server/shared.js';
 import { generateInputTypeDefinitionFields } from '../server/inputs.js';
+import { generateSchemaName, generateZodInferInterfaceType, } from '../server/shared.js';
+import { extractFragmentSourceTextsInSpec, generateZodFragmentSpecCallExpression, } from './fragments.js';
 export function opTypeToName(type) {
     switch (type) {
         case 'QUERY':
@@ -19,50 +18,49 @@ function parametersToFields(parameters) {
         parameters[name],
     ]));
 }
-function generateOperationNode(schema, operation) {
+function generateOperationNode(clientTypeNameBuilders, schema, operation) {
     return ts.factory.createVariableStatement(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(operation.name + 'Operation'), undefined, undefined, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression([
+        ts.factory.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(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.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) {
+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(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.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) {
+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(operation.name + 'Result')), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, operation.fragmentSpec)),
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(resultName)), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, operation.fragmentSpec, undefined, true)),
     ], ts.NodeFlags.Const));
 }
-function generateOperationNodes(scalarsMapping, schema, operation) {
+function generateOperationNodes(clientTypeNameBuilders, scalarsMapping, schema, operation) {
+    const variablesName = clientTypeNameBuilders.variablesTypeName(operation.name);
+    const resultName = clientTypeNameBuilders.resultTypeName(operation.name);
     return [
-        generateOperationZodInputSchema(scalarsMapping, operation),
-        generateZodInferTypeAlias('input', operation.name + 'Variables', generateSchemaName(operation.name + 'Variables')),
+        generateOperationZodInputSchema(scalarsMapping, operation, variablesName),
+        generateZodInferInterfaceType('input', variablesName, generateSchemaName(variablesName)),
         ts.factory.createIdentifier('\n'),
-        genearteOperationZodOutputSchema(scalarsMapping, schema, operation),
-        generateZodInferTypeAlias('output', operation.name + 'Result', generateSchemaName(operation.name + 'Result')),
-        generateOperationNode(schema, operation),
+        genearteOperationZodOutputSchema(scalarsMapping, schema, operation, resultName),
+        generateZodInferInterfaceType('output', resultName, generateSchemaName(resultName)),
+        generateOperationNode(clientTypeNameBuilders, schema, operation),
         ts.factory.createIdentifier('\n'),
     ];
 }
-export function generateOperationsNodes(scalarsMapping, schema) {
+export function generateOperationsNodes(clientTypeNameBuilders, scalarsMapping, schema) {
     return Object.values(schema.client.operations)
         .map((operation) => {
-        return generateOperationNodes(scalarsMapping, schema, operation);
+        return generateOperationNodes(clientTypeNameBuilders, scalarsMapping, schema, operation);
     })
         .flat();
 }

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { getScalarSpecFromMapping } from './scalars/index.js';
 import { invokeMethod } from '../../../shared.js';
-import { generateSchemaName, generateZodInferTypeAlias } from './shared.js';
+import { generateSchemaName, generateZodInferInterfaceType } from './shared.js';
 function generateZodInputTypeSpec(scalarsMapping, type) {
     switch (type._type) {
         case 'Enum': {
@@ -41,26 +41,26 @@ function isFieldLazy(spec) {
             return isFieldLazy(spec.type);
     }
 }
-export function generateInputTypeDefinitionFields(scalarsMapping, fields) {
+export function generateInputTypeDefinitionFields(scalarsMapping, fields, insideLazy) {
     return Object.entries(fields).map(([name, field]) => {
         const fieldSpec = generateZodInputField(scalarsMapping, field);
-        if (isFieldLazy(field.spec)) {
+        if (isFieldLazy(field.spec) && !insideLazy) {
             return ts.factory.createGetAccessorDeclaration([], name, [], undefined, ts.factory.createBlock([ts.factory.createReturnStatement(fieldSpec)], true));
         }
         return ts.factory.createPropertyAssignment(name, fieldSpec);
     });
 }
-function generateZodInputTypeDefinition(scalarsMapping, name, fields) {
+function generateZodInputTypeDefinition(scalarsMapping, name, fields, insideLazy = false) {
     return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
         ts.factory.createVariableDeclaration(generateSchemaName(name), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('object')), undefined, [
-            ts.factory.createObjectLiteralExpression(generateInputTypeDefinitionFields(scalarsMapping, fields), true),
+            ts.factory.createObjectLiteralExpression(generateInputTypeDefinitionFields(scalarsMapping, fields, insideLazy), true),
         ])),
     ], ts.NodeFlags.Const));
 }
 export function generateInputTypeDefinitions(scalarsMapping, input) {
     return [
         generateZodInputTypeDefinition(scalarsMapping, input.name, input.fields),
-        generateZodInferTypeAlias('input', input.name, generateSchemaName(input.name)),
+        generateZodInferInterfaceType('input', input.name, generateSchemaName(input.name)),
         ts.factory.createIdentifier('\n'),
     ];
 }

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

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

package/actors/ts/graphql/generators/server/objects.js

@@ -1,7 +1,7 @@
 /* eslint-disable max-lines */
 import { getScalarSpecFromMapping } from './scalars/mapping.js';
 import ts from 'typescript';
-import { generateSchemaName, generateZodInferTypeAlias } from './shared.js';
+import { generateSchemaName, generateZodInferInterfaceType } from './shared.js';
 import { assertUnreachable } from '../../../../../utils.js';
 import { invokeMethod } from '../../../shared.js';
 function generateZodObjectTypeSpec(scalarsMapping, type) {
@@ -101,7 +101,7 @@ export function generateZodObjectTypeNode(scalarsMapping, object) {
 export function generateObjectTypeNodes(scalarsMapping, object) {
     return [
         generateZodObjectTypeNode(scalarsMapping, object),
-        generateZodInferTypeAlias('output', object.name, generateSchemaName(object.name)),
+        generateZodInferInterfaceType('output', object.name, generateSchemaName(object.name)),
         ts.factory.createIdentifier('\n'),
     ];
 }

package/actors/ts/graphql/generators/server/scalars/additional.d.ts

@@ -17,4 +17,5 @@ export declare const additionalScalarsMapping: {
         readonly inputSchema: ts.CallExpression;
         readonly outputSchema: ts.CallExpression;
     };
+    readonly Duration: ScalarSpec;
 };

package/actors/ts/graphql/generators/server/scalars/additional.js

@@ -1,8 +1,8 @@
 /* eslint-disable max-lines */
 import ts from 'typescript';
-import { buildSymmetricScalarSpec } from './mapping.js';
 import { invokeMethod } from '../../../../shared.js';
 import { builtinScalarsMapping } from './builtin.js';
+import { buildSymmetricScalarSpec } from './mapping.js';
 export const additionalScalarsMapping = {
     Int64: builtinScalarsMapping.Int,
     UUID: builtinScalarsMapping.String,
@@ -40,4 +40,5 @@ export const additionalScalarsMapping = {
             ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), [], [ts.factory.createIdentifier('v')])),
         ]),
     },
+    Duration: buildSymmetricScalarSpec(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'iso'), 'duration'), undefined, [])),
 };

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

@@ -1,8 +1,9 @@
-import ts from 'typescript';
-import { z } from 'zod/v4';
 import { objectNonCallableFieldSpecSchema } from '../../../../../schema/server.js';
 import { inputFieldSpecSchema } from '../../../../../schema/shared.js';
+import ts from 'typescript';
+import { z } from 'zod/v4';
 export declare function generateNonCallableFieldSpec(scalars: string[], spec: z.infer<typeof objectNonCallableFieldSpecSchema> | z.infer<typeof inputFieldSpecSchema>): ts.TypeNode;
 export declare function wrapInMaybeIfNullable(spec: ts.TypeNode, nullable: boolean): ts.TypeNode;
 export declare function generateZodInferTypeAlias(inferType: 'input' | 'output', name: string, typeName: string): ts.TypeAliasDeclaration;
+export declare function generateZodInferInterfaceType(inferType: 'input' | 'output', name: string, typeName: string): ts.InterfaceDeclaration;
 export declare function generateSchemaName(name: string): string;

package/actors/ts/graphql/generators/server/shared.js

@@ -14,10 +14,19 @@ export function wrapInMaybeIfNullable(spec, nullable) {
         : spec;
 }
 export function generateZodInferTypeAlias(inferType, name, typeName) {
-    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), name, undefined, ts.factory.createTypeReferenceNode('z.' + inferType, [
+    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), name, undefined, ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier('z.' + inferType), [
         ts.factory.createTypeQueryNode(ts.factory.createIdentifier(typeName), undefined),
     ]));
 }
+export function generateZodInferInterfaceType(inferType, name, typeName) {
+    return ts.factory.createInterfaceDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), name, undefined, [
+        ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+            ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier('z.' + inferType), [
+                ts.factory.createTypeQueryNode(ts.factory.createIdentifier(typeName), undefined),
+            ]),
+        ]),
+    ], []);
+}
 export function generateSchemaName(name) {
     return name[0].toLowerCase() + name.slice(1) + 'Schema';
 }

package/actors/ts/graphql/generators/server/unions.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { generateSchemaName, generateZodInferTypeAlias } from './shared.js';
+import { generateSchemaName, generateZodInferInterfaceType } from './shared.js';
 import { generateZodObjectTypeExpression } from './objects.js';
 function generateZodUnionTypeNode(scalarsMapping, objects, union) {
     return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
@@ -12,7 +12,7 @@ function generateZodUnionTypeNode(scalarsMapping, objects, union) {
 export function generateUnionTypeDefinitions(scalarsMapping, objects, union) {
     return [
         generateZodUnionTypeNode(scalarsMapping, objects, union),
-        generateZodInferTypeAlias('output', union.name, generateSchemaName(union.name)),
+        generateZodInferInterfaceType('output', union.name, generateSchemaName(union.name)),
         ts.factory.createIdentifier('\n'),
     ];
 }

package/actors/ts/graphql/index.d.ts

@@ -1,2 +1,2 @@
-export { buildGraphqlActor, GraphqlActorConfig } from './actor.js';
+export { build, Config } from './actor.js';
 export { builtinScalarsMapping, additionalScalarsMapping, type BuiltinScalarName, type ScalarSpec, type ScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping, } from './generators/server/scalars/index.js';

package/actors/ts/graphql/index.js

@@ -1,2 +1,2 @@
-export { buildGraphqlActor } from './actor.js';
+export { build } from './actor.js';
 export { builtinScalarsMapping, additionalScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping, } from './generators/server/scalars/index.js';

package/actors/ts/index.d.ts

@@ -1,7 +1,8 @@
 export * as gqlClient from './gql-client/index.js';
 export * as gqlClientReact from './gql-client-react/index.js';
 export * as gqlClientVue from './gql-client-vue/index.js';
+export * as gqlClientFramework from './gql-client-framework/index.js';
 export * as graphql from './graphql/index.js';
-export { type Formatter, type TSActorConfig, renderNodes, loadTsConfigCompilerOptions, addNewLineBetweenNodes, invokeMethod, } from './shared.js';
+export { type Formatter, type TSActorConfig, type ClientTypeNameBuilders, renderNodes, loadTsConfigCompilerOptions, addNewLineBetweenNodes, invokeMethod, } from './shared.js';
 export { generateImportDeclaration } from './utils.js';
 export * as formatters from './formatters/index.js';

package/actors/ts/index.js

@@ -1,6 +1,7 @@
 export * as gqlClient from './gql-client/index.js';
 export * as gqlClientReact from './gql-client-react/index.js';
 export * as gqlClientVue from './gql-client-vue/index.js';
+export * as gqlClientFramework from './gql-client-framework/index.js';
 export * as graphql from './graphql/index.js';
 export { renderNodes, loadTsConfigCompilerOptions, addNewLineBetweenNodes, invokeMethod, } from './shared.js';
 export { generateImportDeclaration } from './utils.js';

package/actors/ts/shared.d.ts

@@ -1,4 +1,9 @@
 import ts from 'typescript';
+export interface ClientTypeNameBuilders {
+    operationTypeName: (operationName: string) => string;
+    variablesTypeName: (operationName: string) => string;
+    resultTypeName: (operationName: string) => string;
+}
 export type Formatter = (code: string) => Promise<string> | string;
 export interface TSActorConfig {
     tsconfigCompilerOptions: ts.CompilerOptions;

package/actors/ts/utils.d.ts

@@ -1,5 +1,3 @@
 import ts from 'typescript';
-export declare function generateImportDeclaration(modulePath: string, imports: (string | {
-    name: string;
-    alias: string;
-})[]): ts.ImportDeclaration;
+export declare function generateImportSpecifier(name: string, typeOnly?: boolean, alias?: string | null): ts.ImportSpecifier;
+export declare function generateImportDeclaration(modulePath: string, imports: ts.ImportSpecifier[]): ts.ImportDeclaration;

package/actors/ts/utils.js

@@ -1,6 +1,7 @@
 import ts from 'typescript';
+export function generateImportSpecifier(name, typeOnly = false, alias = null) {
+    return ts.factory.createImportSpecifier(typeOnly, alias === null ? undefined : ts.factory.createIdentifier(alias), ts.factory.createIdentifier(name));
+}
 export function generateImportDeclaration(modulePath, imports) {
-    return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(imports.map((i) => ts.factory.createImportSpecifier(true, typeof i === 'string'
-        ? undefined
-        : ts.factory.createIdentifier(i.alias), ts.factory.createIdentifier(typeof i === 'string' ? i : i.name))))), ts.factory.createStringLiteral(modulePath));
+    return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(imports)), ts.factory.createStringLiteral(modulePath));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vladimirdev635/gql-codegen",
-    "version": "0.0.108",
+    "version": "0.0.110",
     "description": "",
     "keywords": [],
     "homepage": "https://github.com/Voldemat/graphql-plus-plus#readme",

package/schema/client/operation.d.ts

@@ -41,3 +41,6 @@ export declare const operationSchema: z.ZodObject<{
     }, z.core.$strip>], "_type">;
     sourceText: z.ZodString;
 }, z.core.$strip>;
+export interface Operation extends z.infer<typeof operationSchema> {
+}
+export type OperationType = Operation['type'];

package/schema/utils.d.ts

@@ -1,15 +1,15 @@
 import { PathOrFileDescriptor } from 'fs';
-import { objectFieldSchema, objectFieldSpecSchema, objectSchema, ServerSchema, unionSchema } from './server.js';
-import { ClientSchema } from './client/root.js';
 import { z } from 'zod/v4';
-import { RootSchema } from './root.js';
-import { fieldSelection, fragmentSchema, fragmentSpecSchema } from './client/fragment.js';
 import { argument } from './client/argument.js';
+import { fieldSelection, fragmentSchema, fragmentSpecSchema } from './client/fragment.js';
+import { ClientSchema } from './client/root.js';
+import { RootSchema } from './root.js';
+import { objectFieldSchema, objectFieldSpecSchema, objectSchema, ServerSchema, unionSchema } from './server.js';
 export declare function loadSchemaFromFile<T extends z.ZodType>(p: PathOrFileDescriptor, schema: T): z.infer<T>;
 export declare function loadServerSchemaFromFile(p: PathOrFileDescriptor): ServerSchema;
 export declare function loadClientSchemaFromFile(p: PathOrFileDescriptor): ClientSchema;
-export declare function loadServerSchemaFromGQLSubprocess(gqlPath?: string, gqlArgs?: string[]): Promise<ServerSchema>;
-export declare function loadRootSchemaFromGQLSubprocess(gqlPath?: string, gqlArgs?: string[]): Promise<RootSchema>;
+export declare function loadServerSchemaFromGQLSubprocess(gqlPath?: string, gqlArgs?: string[], maxBuffer?: number | undefined): Promise<ServerSchema>;
+export declare function loadRootSchemaFromGQLSubprocess(gqlPath?: string, gqlArgs?: string[], maxBuffer?: number | undefined): Promise<RootSchema>;
 export declare function buildFragmentFromUnion(union: z.infer<typeof unionSchema>): z.infer<typeof fragmentSchema>;
 export declare function buildSelectionFromFieldSpec(spec: z.infer<typeof objectFieldSpecSchema>): z.infer<typeof fragmentSpecSchema> | null;
 export declare function buildArgumentFromFieldSpec(spec: z.infer<typeof objectFieldSpecSchema>): Record<string, z.infer<typeof argument>>;

package/schema/utils.js

@@ -1,8 +1,8 @@
 /* eslint-disable max-lines */
 import { readFileSync } from 'fs';
-import { serverSchema, } from './server.js';
-import { clientSchema } from './client/root.js';
 import { exec } from 'node:child_process';
+import { clientSchema } from './client/root.js';
+import { serverSchema, } from './server.js';
 export function loadSchemaFromFile(p, schema) {
     return schema.parse(JSON.parse(readFileSync(p).toString()));
 }
@@ -12,9 +12,11 @@ export function loadServerSchemaFromFile(p) {
 export function loadClientSchemaFromFile(p) {
     return loadSchemaFromFile(p, clientSchema);
 }
-export async function loadServerSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs = ['generate']) {
+export async function loadServerSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs = ['generate'], maxBuffer = undefined) {
     const output = await new Promise((resolve, reject) => {
-        exec([gqlPath, ...gqlArgs].join(' '), (err, stdout, stderr) => {
+        exec([gqlPath, ...gqlArgs].join(' '), {
+            maxBuffer,
+        }, (err, stdout, stderr) => {
             if (err !== null) {
                 reject(err);
             }
@@ -26,9 +28,9 @@ export async function loadServerSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs
     });
     return serverSchema.parse(JSON.parse(output));
 }
-export async function loadRootSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs = ['generate']) {
+export async function loadRootSchemaFromGQLSubprocess(gqlPath = 'gql', gqlArgs = ['generate'], maxBuffer = undefined) {
     const output = await new Promise((resolve, reject) => {
-        exec([gqlPath, ...gqlArgs].join(' '), (err, stdout, stderr) => {
+        exec([gqlPath, ...gqlArgs].join(' '), { maxBuffer }, (err, stdout, stderr) => {
             if (err !== null) {
                 reject(err);
             }

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

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