@vladimirdev635/gql-codegen 0.0.108 → 0.0.110

package/actors/ts/gql-client-framework/generators/help-nodes/index.js

@@ -0,0 +1,55 @@
+import ts from 'typescript';
+import { generateSdkTypeNode } from './sdk-operations-type-node.js';
+import { generateSdkType } from './sdk-type.js';
+import { generateSyncHookBuilder, generateSyncHookType, } from './sync-hook-builders.js';
+import { generateLazyHookBuilder, generateLazyHookType, } from './lazy-hook-builder.js';
+import { generateSubscriptionHookBuilder, generateSubscriptionHookType, } from './subscription-hook-builders.js';
+function generateSdkTypeNodes(config, context, state) {
+    return [
+        ...(state.hasQueries
+            ? [
+                generateSdkTypeNode(config, 'QUERY', context.schema.client.operations),
+                ts.factory.createIdentifier('\n'),
+            ]
+            : []),
+        ...(state.hasMutations
+            ? [
+                generateSdkTypeNode(config, 'MUTATION', context.schema.client.operations),
+                ts.factory.createIdentifier('\n'),
+            ]
+            : []),
+        ...(state.hasSubscriptions
+            ? [
+                generateSdkTypeNode(config, 'SUBSCRIPTION', context.schema.client.operations),
+                ts.factory.createIdentifier('\n'),
+            ]
+            : []),
+    ];
+}
+export function generateHelpNodes(config, context, state) {
+    return [
+        ...(state.hasQueries
+            ? [
+                generateSyncHookType(config),
+                ts.factory.createIdentifier('\n'),
+                generateSyncHookBuilder(config),
+            ]
+            : []),
+        ...(state.hasQueries || state.hasMutations
+            ? [
+                generateLazyHookType(config),
+                ts.factory.createIdentifier('\n'),
+                generateLazyHookBuilder(config),
+            ]
+            : []),
+        ...(state.hasSubscriptions
+            ? [
+                generateSubscriptionHookType(config),
+                ts.factory.createIdentifier('\n'),
+                generateSubscriptionHookBuilder(config),
+            ]
+            : []),
+        ...generateSdkTypeNodes(config, context, state),
+        generateSdkType(config, state),
+    ];
+}

package/actors/ts/gql-client-framework/generators/help-nodes/lazy-hook-builder.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import { Config } from '../../actor.js';
+export declare function generateLazyHookType(config: Config): ts.TypeAliasDeclaration;
+export declare function generateLazyHookBuilder(config: Config): ts.FunctionDeclaration;

package/actors/ts/gql-client-framework/generators/help-nodes/lazy-hook-builder.js

@@ -0,0 +1,44 @@
+/* oxlint-disable max-lines */
+import ts from 'typescript';
+function generateLazyHookReturnType(variablesTypeNode, resultTypeNode) {
+    return ts.factory.createTypeReferenceNode('UseLazyOperationHookReturnType', [
+        ts.factory.createTypeReferenceNode('TRequestContext'),
+        variablesTypeNode,
+        resultTypeNode,
+    ]);
+}
+export function generateLazyHookType(config) {
+    return ts.factory.createTypeAliasDeclaration([], config.sdk.lazyHookTypeName, [
+        ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TVariables'),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TResult'),
+    ], ts.factory.createFunctionTypeNode(undefined, [], generateLazyHookReturnType(ts.factory.createTypeReferenceNode('TVariables'), ts.factory.createTypeReferenceNode('TResult'))));
+}
+export function generateLazyHookBuilder(config) {
+    return ts.factory.createFunctionDeclaration(undefined, undefined, config.sdk.lazyHookBuilderName, [
+        ts.factory.createTypeParameterDeclaration(undefined, 'TExecutor', ts.factory.createTypeReferenceNode('types.IExecutor', [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ])),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TOperation', ts.factory.createTypeReferenceNode('types.SyncOperation', [
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+        ])),
+    ], [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('TExecutor')),
+        ts.factory.createParameterDeclaration(undefined, undefined, 'operation', undefined, ts.factory.createTypeReferenceNode('TOperation')),
+    ], ts.factory.createTypeReferenceNode(config.sdk.lazyHookTypeName, [
+        ts.factory.createTypeReferenceNode('TRequestContext'),
+        ts.factory.createTypeReferenceNode('types.OperationVariables', [
+            ts.factory.createTypeReferenceNode('TOperation'),
+        ]),
+        ts.factory.createTypeReferenceNode('types.OperationResult', [
+            ts.factory.createTypeReferenceNode('TOperation'),
+        ]),
+    ]), ts.factory.createBlock([
+        ts.factory.createReturnStatement(ts.factory.createArrowFunction(undefined, undefined, [], generateLazyHookReturnType(ts.factory.createTypeReferenceNode('types.OperationVariables', [ts.factory.createTypeReferenceNode('TOperation')]), ts.factory.createTypeReferenceNode('types.OperationResult', [ts.factory.createTypeReferenceNode('TOperation')])), ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier('useLazyOperation'), [], [
+            ts.factory.createIdentifier('executor'),
+            ts.factory.createIdentifier('operation'),
+        ]))),
+    ]));
+}

package/actors/ts/gql-client-framework/generators/help-nodes/sdk-operations-type-node.d.ts

@@ -0,0 +1,4 @@
+import { Operation, OperationType } from '../../../../../schema/client/operation.js';
+import ts from 'typescript';
+import { Config } from '../../actor.js';
+export declare function generateSdkTypeNode(config: Config, type: OperationType, operations: Record<string, Operation>): ts.InterfaceDeclaration;

package/actors/ts/gql-client-framework/generators/help-nodes/sdk-operations-type-node.js

@@ -0,0 +1,45 @@
+import ts from 'typescript';
+import { assertUnreachable } from '../../../../../utils.js';
+function getHookTypeName(config, type) {
+    switch (type) {
+        case 'SYNC':
+            return config.sdk.syncHookTypeName;
+        case 'LAZY':
+            return config.sdk.lazyHookTypeName;
+        case 'SUBSCRIPTION':
+            return config.sdk.subscriptionHookTypeName;
+    }
+}
+function generateOperationPropertySignature(config, hookName, type, operation) {
+    return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(hookName), undefined, ts.factory.createTypeReferenceNode(getHookTypeName(config, type), [
+        ts.factory.createTypeReferenceNode('TRequestContext'),
+        ts.factory.createTypeReferenceNode(config.sdk.clientTypeNameBuilders.variablesTypeName(operation.name)),
+        ts.factory.createTypeReferenceNode(config.sdk.clientTypeNameBuilders.resultTypeName(operation.name)),
+    ]));
+}
+export function generateSdkTypeNode(config, type, operations) {
+    return ts.factory.createInterfaceDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(config.sdk.operationHooksTypeNameBuilder(type)), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), ts.factory.createTypeReferenceNode('types.RequestContext'), undefined),
+    ], undefined, Object.values(operations)
+        .filter((op) => op.type == type)
+        .map((op) => {
+        switch (op.type) {
+            case 'QUERY':
+                return [
+                    generateOperationPropertySignature(config, config.sdk.hookNameBuilders.query.immediate(op.name), 'SYNC', op),
+                    generateOperationPropertySignature(config, config.sdk.hookNameBuilders.query.lazy(op.name), 'LAZY', op),
+                ];
+            case 'MUTATION':
+                return [
+                    generateOperationPropertySignature(config, config.sdk.hookNameBuilders.mutation.lazy(op.name), 'LAZY', op),
+                ];
+            case 'SUBSCRIPTION':
+                return [
+                    generateOperationPropertySignature(config, config.sdk.hookNameBuilders.subscription.immediate(op.name), 'SUBSCRIPTION', op),
+                ];
+            default:
+                return assertUnreachable(op.type);
+        }
+    })
+        .flat());
+}

package/actors/ts/gql-client-framework/generators/help-nodes/sdk-type.d.ts

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+import { Config } from '../../actor.js';
+export declare function generateSdkType(config: Config, state: {
+    hasQueries: boolean;
+    hasMutations: boolean;
+    hasSubscriptions: boolean;
+}): ts.InterfaceDeclaration;

package/actors/ts/gql-client-framework/generators/help-nodes/sdk-type.js

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+function generateSdkPropertySignature(key, typeName) {
+    return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(key), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('TRequestContext')),
+    ]));
+}
+export function generateSdkType(config, state) {
+    const properties = [];
+    if (state.hasQueries) {
+        properties.push(generateSdkPropertySignature(config.sdk.queriesKey, config.sdk.operationHooksTypeNameBuilder('QUERY')));
+    }
+    if (state.hasMutations) {
+        properties.push(generateSdkPropertySignature(config.sdk.mutationsKey, config.sdk.operationHooksTypeNameBuilder('MUTATION')));
+    }
+    if (state.hasSubscriptions) {
+        properties.push(generateSdkPropertySignature(config.sdk.subscriptionsKey, config.sdk.operationHooksTypeNameBuilder('SUBSCRIPTION')));
+    }
+    return ts.factory.createInterfaceDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(config.sdk.typeName), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), ts.factory.createTypeReferenceNode('types.RequestContext'), undefined),
+    ], undefined, properties);
+}

package/actors/ts/gql-client-framework/generators/help-nodes/subscription-hook-builders.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import { Config } from '../../actor.js';
+export declare function generateSubscriptionHookType(config: Config): ts.TypeAliasDeclaration;
+export declare function generateSubscriptionHookBuilder(config: Config): ts.FunctionDeclaration;

package/actors/ts/gql-client-framework/generators/help-nodes/subscription-hook-builders.js

@@ -0,0 +1,52 @@
+/* oxlint-disable max-lines */
+import ts from 'typescript';
+function generateSubscriptionHookReturnType(resultTypeNode) {
+    return ts.factory.createTypeReferenceNode('UseSubscriptionHookReturnType', [
+        resultTypeNode,
+    ]);
+}
+export function generateSubscriptionHookType(config) {
+    return ts.factory.createTypeAliasDeclaration([], config.sdk.subscriptionHookTypeName, [
+        ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TVariables'),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TResult'),
+    ], ts.factory.createFunctionTypeNode(undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, config.sdk.buildVariablesType(ts.factory.createTypeReferenceNode('TVariables'))),
+        ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')),
+    ], generateSubscriptionHookReturnType(ts.factory.createTypeReferenceNode('TResult'))));
+}
+export function generateSubscriptionHookBuilder(config) {
+    return ts.factory.createFunctionDeclaration(undefined, undefined, config.sdk.syncHookBuilderName, [
+        ts.factory.createTypeParameterDeclaration(undefined, 'TExecutor', ts.factory.createTypeReferenceNode('types.IExecutor', [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ])),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TOperation', ts.factory.createTypeReferenceNode('types.SubscriptionOperation', [
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+        ])),
+    ], [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('TExecutor')),
+        ts.factory.createParameterDeclaration(undefined, undefined, 'operation', undefined, ts.factory.createTypeReferenceNode('TOperation')),
+    ], ts.factory.createTypeReferenceNode(config.sdk.subscriptionHookTypeName, [
+        ts.factory.createTypeReferenceNode('TRequestContext'),
+        ts.factory.createTypeReferenceNode('types.OperationVariables', [
+            ts.factory.createTypeReferenceNode('TOperation'),
+        ]),
+        ts.factory.createTypeReferenceNode('types.OperationResult', [
+            ts.factory.createTypeReferenceNode('TOperation'),
+        ]),
+    ]), ts.factory.createBlock([
+        ts.factory.createReturnStatement(ts.factory.createArrowFunction(undefined, undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, config.sdk.buildVariablesType(ts.factory.createTypeReferenceNode('types.OperationVariables', [
+                ts.factory.createTypeReferenceNode('TOperation'),
+            ]))),
+            ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, config.sdk.buildRequestContextType(ts.factory.createTypeReferenceNode('TRequestContext'))),
+        ], generateSubscriptionHookReturnType(ts.factory.createTypeReferenceNode('types.OperationResult', [ts.factory.createTypeReferenceNode('TOperation')])), ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier('useSubscription'), [], [
+            ts.factory.createIdentifier('executor'),
+            ts.factory.createIdentifier('operation'),
+            ts.factory.createIdentifier('variables'),
+            ts.factory.createIdentifier('requestContext'),
+        ]))),
+    ]));
+}

package/actors/ts/gql-client-framework/generators/help-nodes/sync-hook-builders.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import { Config } from '../../actor.js';
+export declare function generateSyncHookType(config: Config): ts.TypeAliasDeclaration;
+export declare function generateSyncHookBuilder(config: Config): ts.FunctionDeclaration;

package/actors/ts/gql-client-framework/generators/help-nodes/sync-hook-builders.js

@@ -0,0 +1,52 @@
+/* oxlint-disable max-lines */
+import ts from 'typescript';
+function generateSyncHookReturnType(resultTypeNode) {
+    return ts.factory.createTypeReferenceNode('UseOperationHookReturnType', [
+        resultTypeNode,
+    ]);
+}
+export function generateSyncHookType(config) {
+    return ts.factory.createTypeAliasDeclaration([], config.sdk.syncHookTypeName, [
+        ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TVariables'),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TResult'),
+    ], ts.factory.createFunctionTypeNode(undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, config.sdk.buildVariablesType(ts.factory.createTypeReferenceNode('TVariables'))),
+        ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, config.sdk.buildRequestContextType(ts.factory.createTypeReferenceNode('TRequestContext'))),
+    ], generateSyncHookReturnType(ts.factory.createTypeReferenceNode('TResult'))));
+}
+export function generateSyncHookBuilder(config) {
+    return ts.factory.createFunctionDeclaration(undefined, undefined, config.sdk.syncHookBuilderName, [
+        ts.factory.createTypeParameterDeclaration(undefined, 'TExecutor', ts.factory.createTypeReferenceNode('types.IExecutor', [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ])),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ts.factory.createTypeParameterDeclaration(undefined, 'TOperation', ts.factory.createTypeReferenceNode('types.SyncOperation', [
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+        ])),
+    ], [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('TExecutor')),
+        ts.factory.createParameterDeclaration(undefined, undefined, 'operation', undefined, ts.factory.createTypeReferenceNode('TOperation')),
+    ], ts.factory.createTypeReferenceNode(config.sdk.syncHookTypeName, [
+        ts.factory.createTypeReferenceNode('TRequestContext'),
+        ts.factory.createTypeReferenceNode('types.OperationVariables', [
+            ts.factory.createTypeReferenceNode('TOperation'),
+        ]),
+        ts.factory.createTypeReferenceNode('types.OperationResult', [
+            ts.factory.createTypeReferenceNode('TOperation'),
+        ]),
+    ]), ts.factory.createBlock([
+        ts.factory.createReturnStatement(ts.factory.createArrowFunction(undefined, undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, config.sdk.buildVariablesType(ts.factory.createTypeReferenceNode('types.OperationVariables', [
+                ts.factory.createTypeReferenceNode('TOperation'),
+            ]))),
+            ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, config.sdk.buildRequestContextType(ts.factory.createTypeReferenceNode('TRequestContext'))),
+        ], generateSyncHookReturnType(ts.factory.createTypeReferenceNode('types.OperationResult', [ts.factory.createTypeReferenceNode('TOperation')])), ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier('useOperation'), [], [
+            ts.factory.createIdentifier('executor'),
+            ts.factory.createIdentifier('operation'),
+            ts.factory.createIdentifier('variables'),
+            ts.factory.createIdentifier('requestContext'),
+        ]))),
+    ]));
+}

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

@@ -0,0 +1,88 @@
+import ts from 'typescript';
+import { generateHelpNodes } from './help-nodes/index.js';
+function getHookBuilderName(config, type) {
+    switch (type) {
+        case 'SYNC':
+            return config.sdk.syncHookBuilderName;
+        case 'LAZY':
+            return config.sdk.lazyHookBuilderName;
+        case 'SUBSCRIPTION':
+            return config.sdk.subscriptionHookBuilderName;
+    }
+}
+function generateHookValueExpression(config, operationName, type) {
+    return ts.factory.createCallExpression(ts.factory.createIdentifier(getHookBuilderName(config, type)), undefined, [
+        ts.factory.createIdentifier('executor'),
+        ts.factory.createIdentifier(operationName),
+    ]);
+}
+export function generateNodes(config, context) {
+    const graphqlImports = [];
+    const queryNodes = [];
+    const mutationNodes = [];
+    const subscriptionNodes = [];
+    for (const operation of Object.values(context.schema.client.operations)) {
+        const operationName = config.sdk.clientTypeNameBuilders.operationTypeName(operation.name);
+        const variablesName = config.sdk.clientTypeNameBuilders.variablesTypeName(operation.name);
+        const resultName = config.sdk.clientTypeNameBuilders.resultTypeName(operation.name);
+        graphqlImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(operationName)), ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier(variablesName)), ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier(resultName)));
+        switch (operation.type) {
+            case 'SUBSCRIPTION': {
+                subscriptionNodes.push(ts.factory.createPropertyAssignment(config.sdk.hookNameBuilders.subscription.immediate(operation.name), generateHookValueExpression(config, operationName, 'SUBSCRIPTION')));
+                break;
+            }
+            case 'MUTATION': {
+                mutationNodes.push(ts.factory.createPropertyAssignment(config.sdk.hookNameBuilders.mutation.lazy(operation.name), generateHookValueExpression(config, operationName, 'LAZY')));
+                break;
+            }
+            case 'QUERY': {
+                queryNodes.push(ts.factory.createPropertyAssignment(config.sdk.hookNameBuilders.query.immediate(operation.name), generateHookValueExpression(config, operationName, 'SYNC')), ts.factory.createPropertyAssignment(config.sdk.hookNameBuilders.query.lazy(operation.name), generateHookValueExpression(config, operationName, 'LAZY')));
+                break;
+            }
+        }
+    }
+    const gqlClientReactImports = [];
+    const state = {
+        hasQueries: queryNodes.length !== 0,
+        hasMutations: mutationNodes.length !== 0,
+        hasSubscriptions: subscriptionNodes.length !== 0,
+    };
+    const returnObjectNodes = [];
+    if (state.hasQueries) {
+        gqlClientReactImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useOperation')));
+        gqlClientReactImports.push(ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseOperationHookReturnType')));
+        gqlClientReactImports.push(ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('types')));
+        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.queriesKey, ts.factory.createObjectLiteralExpression(queryNodes, true)));
+    }
+    if (state.hasMutations) {
+        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.mutationsKey, ts.factory.createObjectLiteralExpression(mutationNodes, true)));
+    }
+    if (state.hasQueries || state.hasMutations) {
+        gqlClientReactImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useLazyOperation')));
+        gqlClientReactImports.push(ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseLazyOperationHookReturnType')));
+    }
+    if (state.hasSubscriptions) {
+        gqlClientReactImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useSubscription')), ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseSubscriptionHookReturnType')));
+        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.subscriptionsKey, ts.factory.createObjectLiteralExpression(subscriptionNodes, true)));
+    }
+    return [
+        ...config.importDeclarations,
+        ts.factory.createImportDeclaration([], ts.factory.createImportClause(undefined, undefined, ts.factory.createNamedImports(gqlClientReactImports)), ts.factory.createStringLiteral(config.frameworkImportName)),
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(undefined, undefined, ts.factory.createNamedImports(graphqlImports)), ts.factory.createStringLiteral(config.graphqlModulePath)),
+        ts.factory.createIdentifier('\n'),
+        ...generateHelpNodes(config, context, state),
+        ts.factory.createIdentifier('\n'),
+        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [
+            ts.factory.createTypeParameterDeclaration(undefined, 'TExecutor', ts.factory.createTypeReferenceNode('types.IExecutor', [
+                ts.factory.createTypeReferenceNode('TRequestContext'),
+            ])),
+            ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ], [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('TExecutor')),
+        ], ts.factory.createTypeReferenceNode(config.sdk.typeName, [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ]), ts.factory.createBlock([
+            ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(returnObjectNodes, true)),
+        ], true)),
+    ];
+}

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

@@ -0,0 +1 @@
+export { type Config, type SDKConfig, build } from './actor.js';

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

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

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

@@ -1,15 +1,8 @@
-import { PathOrFileDescriptor } from 'fs';
 import { Actor, ActorContext } from '../../../config.js';
-import { TSActorConfig } from '../shared.js';
-import ts from 'typescript';
-export interface Config extends TSActorConfig {
-    outPath: PathOrFileDescriptor;
-    importDeclarations: ts.ImportDeclaration[];
-    graphqlModulePath: string;
-    sdk: {
-        queriesKey: string;
-        mutationsKey: string;
-        subscriptionsKey: string;
-    };
+import { Config as FrameworkConfig, SDKConfig as FrameworkSDKConfig } from '../gql-client-framework/index.js';
+export interface SDKConfig extends Omit<FrameworkSDKConfig, 'buildVariablesType'> {
+}
+export interface Config extends Omit<FrameworkConfig, 'frameworkImportName' | 'sdk'> {
+    sdk: SDKConfig;
 }
 export declare function build(config: Config): Actor<ActorContext>;

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

@@ -1,11 +1,12 @@
-import { writeFileSync } from 'fs';
-import { renderNodes } from '../shared.js';
-import { generateNodes } from './generators/main.js';
-async function actor(config, context) {
-    const nodes = generateNodes(config, context);
-    const code = await renderNodes(config, nodes);
-    writeFileSync(config.outPath, code);
-}
+import { build as frameworkBuild, } from '../gql-client-framework/index.js';
 export function build(config) {
-    return (context) => actor(config, context);
+    return frameworkBuild({
+        ...config,
+        frameworkImportName: '@vladimirdev635/gql-client-react',
+        sdk: {
+            ...config.sdk,
+            buildVariablesType: (variablesTypeNode) => variablesTypeNode,
+            buildRequestContextType: (requestContextTypeNode) => requestContextTypeNode,
+        },
+    });
 }

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

@@ -1 +1 @@
-export { type Config, build } from './actor.js';
+export { type Config, type SDKConfig, build } from './actor.js';

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

@@ -1,15 +1,8 @@
 import { Actor, ActorContext } from '../../../config.js';
-import { PathOrFileDescriptor } from 'fs';
-import ts from 'typescript';
-import { TSActorConfig } from '../shared.js';
-export interface Config extends TSActorConfig {
-    outPath: PathOrFileDescriptor;
-    importDeclarations: ts.ImportDeclaration[];
-    graphqlModulePath: string;
-    sdk: {
-        queriesKey: string;
-        mutationsKey: string;
-        subscriptionsKey: string;
-    };
+import { Config as FrameworkConfig, SDKConfig as FrameworkSDKConfig } from '../gql-client-framework/index.js';
+export interface SDKConfig extends Omit<FrameworkSDKConfig, 'buildVariablesType'> {
+}
+export interface Config extends Omit<FrameworkConfig, 'frameworkImportName' | 'sdk'> {
+    sdk: SDKConfig;
 }
 export declare function build(config: Config): Actor<ActorContext>;

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

@@ -1,11 +1,29 @@
-import { writeFileSync } from 'fs';
-import { renderNodes } from '../shared.js';
-import { generateNodes } from './generators/main.js';
-async function actor(config, context) {
-    const nodes = generateNodes(config, context);
-    const code = await renderNodes(config, nodes);
-    writeFileSync(config.outPath, code);
-}
+import { build as frameworkBuild, } from '../gql-client-framework/index.js';
+import ts from 'typescript';
 export function build(config) {
-    return (context) => actor(config, context);
+    return frameworkBuild({
+        ...config,
+        importDeclarations: [
+            ...config.importDeclarations,
+            ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(ts.SyntaxKind.TypeKeyword, undefined, ts.factory.createNamedImports([
+                ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('Ref')),
+            ])), ts.factory.createStringLiteral('vue')),
+        ],
+        frameworkImportName: '@vladimirdev635/gql-client-vue',
+        sdk: {
+            ...config.sdk,
+            buildVariablesType: (variablesTypeNode) => ts.factory.createUnionTypeNode([
+                variablesTypeNode,
+                ts.factory.createTypeReferenceNode('Ref', [
+                    variablesTypeNode,
+                ]),
+            ]),
+            buildRequestContextType: (requestContextTypeNode) => ts.factory.createUnionTypeNode([
+                requestContextTypeNode,
+                ts.factory.createTypeReferenceNode('Ref', [
+                    requestContextTypeNode,
+                ]),
+            ]),
+        },
+    });
 }

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

@@ -1 +1 @@
-export { type Config, build } from './actor.js';
+export { type Config, type SDKConfig, build } from './actor.js';

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

@@ -1,12 +1,13 @@
-import { ScalarsMapping } from './generators/server/scalars/index.js';
+import { Actor, ActorContext } from '../../../config.js';
 import { PathOrFileDescriptor } from 'fs';
 import ts from 'typescript';
-import { Actor, ActorContext } from '../../../config.js';
-import { TSActorConfig } from '../shared.js';
-export interface GraphqlActorConfig extends TSActorConfig {
+import { ClientTypeNameBuilders, TSActorConfig } from '../shared.js';
+import { ScalarsMapping } from './generators/server/scalars/index.js';
+export interface Config extends TSActorConfig {
     outPath: PathOrFileDescriptor;
     scalarsMapping: ScalarsMapping;
     importDeclarations: ts.ImportDeclaration[];
     onlyRequiredForOperations: boolean;
+    clientTypeNameBuilders: ClientTypeNameBuilders;
 }
-export declare function buildGraphqlActor(config: GraphqlActorConfig): Actor<ActorContext>;
+export declare function build(config: Config): Actor<ActorContext>;

package/actors/ts/graphql/actor.js

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

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

@@ -1,6 +1,6 @@
-import ts from 'typescript';
-import { RootSchema } from '../../../../../schema/root.js';
 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[];
@@ -90,6 +90,6 @@ declare function resolveSelections(specSelections: z.infer<typeof objectSelectio
         })[];
     } | null;
 })[];
-export declare function generateZodFragmentSpecCallExpression(scalarsMapping: ScalarsMapping, schema: RootSchema, spec: FragmentSpecSchemaType, typenameConfig?: Parameters<typeof resolveSelections>[1]): ts.CallExpression;
+export declare function 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 {};