@vladimirdev635/gql-codegen 0.0.109 → 0.0.111

package/actors/text-diff.d.ts

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

package/actors/text-diff.js

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

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

@@ -1,7 +1,8 @@
+import { Actor, ActorContext } from '../../../config.js';
+import { OperationType } from '../../../schema/client/operation.js';
 import { PathOrFileDescriptor } from 'fs';
 import ts from 'typescript';
-import { Actor, ActorContext } from '../../../config.js';
-import { TSActorConfig } from '../shared.js';
+import { ClientTypeNameBuilders, TSActorConfig } from '../shared.js';
 export type OperationReturnType = 'ExecuteResult' | 'ExecuteResult.result';
 export interface SDKConfig {
     defaultOperationReturnType: OperationReturnType;
@@ -9,6 +10,11 @@ export interface SDKConfig {
     queriesKey: string;
     mutationsKey: string;
     subscriptionsKey: string;
+    gqlSyncMethodFuncTypeName: string;
+    gqlSubscriptionMethodFuncTypeName: string;
+    operationRequestsTypeNameBuilder: (type: OperationType) => string;
+    typeName: string;
+    clientTypeNameBuilders: ClientTypeNameBuilders;
 }
 export interface Config extends TSActorConfig {
     outPath: PathOrFileDescriptor;

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

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

package/actors/ts/gql-client/generators/help-nodes/build-subscription-callback-function.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import { Config, OperationReturnType } from '../../actor.js';
+export declare function createBuildSubscriptionCallbackFunctionName(returnType: OperationReturnType): string;
+export declare function generateBuildSubscriptionCallbackFunction(config: Config, returnType: OperationReturnType): ts.Node;

package/actors/ts/gql-client/generators/help-nodes/build-subscription-callback-function.js

@@ -0,0 +1,35 @@
+/* oxlint-disable max-lines */
+import ts from 'typescript';
+import { generateCallbackArrowFunction } from './callback-arrow-func.js';
+export function createBuildSubscriptionCallbackFunctionName(returnType) {
+    switch (returnType) {
+        case 'ExecuteResult':
+            return 'buildSubscriptionExecuteResultCallback';
+        case 'ExecuteResult.result':
+            return 'buildSubscriptionResultCallback';
+    }
+}
+export function generateBuildSubscriptionCallbackFunction(config, returnType) {
+    return ts.factory.createFunctionDeclaration(undefined, undefined, ts.factory.createIdentifier(createBuildSubscriptionCallbackFunctionName(returnType)), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TExecutor'), ts.factory.createTypeReferenceNode('types.IExecutor', [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ]), undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('types.RequestContext'), undefined), undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('V'), undefined, undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('R'), undefined, undefined),
+    ], [
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('executor'), undefined, ts.factory.createTypeReferenceNode('TExecutor'), undefined),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('operation'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('types.SubscriptionOperation'), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('V'), undefined),
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('R'), undefined),
+        ]), undefined),
+    ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(config.sdk.gqlSubscriptionMethodFuncTypeName), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('TRequestContext'), undefined),
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('V'), undefined),
+        returnType === 'ExecuteResult.result'
+            ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('R'))
+            : ts.factory.createTypeReferenceNode('types.ExecuteResult', [ts.factory.createTypeReferenceNode('R')]),
+    ]), ts.factory.createBlock([
+        ts.factory.createReturnStatement(generateCallbackArrowFunction(config, 'V', 'R', true, returnType)),
+    ], true));
+}

package/actors/ts/gql-client/generators/help-nodes/build-sync-callback-function.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import { Config, OperationReturnType } from '../../actor.js';
+export declare function createBuildSyncCallbackFunctionName(returnType: OperationReturnType): string;
+export declare function generateBuildSyncCallbackFunction(config: Config, returnType: OperationReturnType): ts.Node;

package/actors/ts/gql-client/generators/help-nodes/build-sync-callback-function.js

@@ -0,0 +1,35 @@
+/* oxlint-disable max-lines */
+import ts from 'typescript';
+import { generateCallbackArrowFunction } from './callback-arrow-func.js';
+export function createBuildSyncCallbackFunctionName(returnType) {
+    switch (returnType) {
+        case 'ExecuteResult':
+            return 'buildSyncExecuteResultCallback';
+        case 'ExecuteResult.result':
+            return 'buildSyncResultCallback';
+    }
+}
+export function generateBuildSyncCallbackFunction(config, returnType) {
+    return ts.factory.createFunctionDeclaration(undefined, undefined, ts.factory.createIdentifier(createBuildSyncCallbackFunctionName(returnType)), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TExecutor'), ts.factory.createTypeReferenceNode('types.IExecutor', [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ]), undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('types.RequestContext'), undefined), undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('V'), undefined, undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('R'), undefined, undefined),
+    ], [
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('executor'), undefined, ts.factory.createTypeReferenceNode('TExecutor'), undefined),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('operation'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('types.SyncOperation'), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('V'), undefined),
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('R'), undefined),
+        ]), undefined),
+    ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(config.sdk.gqlSyncMethodFuncTypeName), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('TRequestContext'), undefined),
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('V'), undefined),
+        returnType === 'ExecuteResult.result'
+            ? ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('R'))
+            : ts.factory.createTypeReferenceNode('types.ExecuteResult', [ts.factory.createTypeReferenceNode('R')]),
+    ]), ts.factory.createBlock([
+        ts.factory.createReturnStatement(generateCallbackArrowFunction(config, 'V', 'R', false, returnType)),
+    ], true));
+}

package/actors/ts/gql-client/generators/help-nodes/callback-arrow-func.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+import { Config, OperationReturnType } from '../../actor.js';
+export declare function generateCallbackArrowFunction(config: Config, variablesTypeName: string, resultTypeName: string, isSubscription: boolean, returnType: OperationReturnType): ts.ArrowFunction;

package/actors/ts/gql-client/generators/help-nodes/callback-arrow-func.js

@@ -0,0 +1,15 @@
+import ts from 'typescript';
+import { generateFunctionBlock } from '../operation-function-block.js';
+import { createReturnTypeNode } from '../operation-return-type.js';
+export function generateCallbackArrowFunction(config, variablesTypeName, resultTypeName, isSubscription, returnType) {
+    const funcArgs = [
+        ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, ts.factory.createTypeReferenceNode(variablesTypeName)),
+        ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')),
+    ];
+    if (isSubscription) {
+        funcArgs.push(ts.factory.createParameterDeclaration(undefined, undefined, 'controller', undefined, ts.factory.createTypeReferenceNode('AbortController')));
+    }
+    return ts.factory.createArrowFunction(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Async), undefined, funcArgs, ts.factory.createTypeReferenceNode('Promise', [
+        createReturnTypeNode(resultTypeName, returnType, isSubscription),
+    ]), ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), generateFunctionBlock(isSubscription, returnType));
+}

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

@@ -0,0 +1,9 @@
+import { ActorContext } from '../../../../../config.js';
+import { Config, OperationReturnType } from '../../actor.js';
+import ts from 'typescript';
+export declare function hasReturnType(config: Config, returnType: OperationReturnType): boolean;
+export declare function generateHelpNodes(config: Config, context: ActorContext, state: {
+    hasQueries: boolean;
+    hasMutations: boolean;
+    hasSubscriptions: boolean;
+}): ts.Node[];

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

@@ -0,0 +1,71 @@
+import { generateSdkTypeNode } from './sdk-operations-type-node.js';
+import { generateSdkType } from './sdk-type.js';
+import { generateBuildSyncCallbackFunction } from './build-sync-callback-function.js';
+import { generateBuildSubscriptionCallbackFunction } from './build-subscription-callback-function.js';
+import { generateSyncMethodFuncAlias } from './sync-method-func-alias.js';
+import { generateSubscriptionMethodFuncAlias } from './subscription-method-func-alias.js';
+function generateSdkTypeNodes(config, context, state) {
+    return [
+        ...(state.hasQueries
+            ? [
+                generateSdkTypeNode(config, 'QUERY', context.schema.client.operations),
+            ]
+            : []),
+        ...(state.hasMutations
+            ? [
+                generateSdkTypeNode(config, 'MUTATION', context.schema.client.operations),
+            ]
+            : []),
+        ...(state.hasSubscriptions
+            ? [
+                generateSdkTypeNode(config, 'SUBSCRIPTION', context.schema.client.operations),
+            ]
+            : []),
+    ];
+}
+export function hasReturnType(config, returnType) {
+    return (config.sdk.defaultOperationReturnType == returnType ||
+        Object.values(config.sdk.operationReturnTypeMapping).includes(returnType));
+}
+export function generateHelpNodes(config, context, state) {
+    const hasExecuteResultType = hasReturnType(config, 'ExecuteResult');
+    const hasResultType = hasReturnType(config, 'ExecuteResult.result');
+    return [
+        ...(state.hasQueries || state.hasMutations
+            ? [generateSyncMethodFuncAlias(config)]
+            : []),
+        ...(state.hasSubscriptions
+            ? [generateSubscriptionMethodFuncAlias(config)]
+            : []),
+        ...generateSdkTypeNodes(config, context, state),
+        generateSdkType(config, state),
+        ...(state.hasQueries || state.hasMutations
+            ? [
+                ...(hasExecuteResultType
+                    ? [
+                        generateBuildSyncCallbackFunction(config, 'ExecuteResult'),
+                    ]
+                    : []),
+                ...(hasResultType
+                    ? [
+                        generateBuildSyncCallbackFunction(config, 'ExecuteResult.result'),
+                    ]
+                    : []),
+            ]
+            : []),
+        ...(state.hasSubscriptions
+            ? [
+                ...(hasExecuteResultType
+                    ? [
+                        generateBuildSubscriptionCallbackFunction(config, 'ExecuteResult'),
+                    ]
+                    : []),
+                ...(hasResultType
+                    ? [
+                        generateBuildSubscriptionCallbackFunction(config, 'ExecuteResult.result'),
+                    ]
+                    : []),
+            ]
+            : []),
+    ];
+}

package/actors/ts/gql-client/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/generators/help-nodes/sdk-operations-type-node.js

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+function generateOperationPropertySignature(config, type, operation) {
+    return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(operation.name), undefined, ts.factory.createTypeReferenceNode(type !== 'SUBSCRIPTION'
+        ? config.sdk.gqlSyncMethodFuncTypeName
+        : config.sdk.gqlSubscriptionMethodFuncTypeName, [
+        ts.factory.createTypeReferenceNode('TRequestContext'),
+        ts.factory.createTypeReferenceNode(operation.name + 'Variables'),
+        ts.factory.createTypeReferenceNode(operation.name + 'Result', undefined),
+    ]));
+}
+export function generateSdkTypeNode(config, type, operations) {
+    return ts.factory.createInterfaceDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(config.sdk.operationRequestsTypeNameBuilder(type)), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), undefined, undefined),
+    ], undefined, Object.values(operations)
+        .filter((op) => op.type == type)
+        .map((op) => generateOperationPropertySignature(config, type, op)));
+}

package/actors/ts/gql-client/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/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'), undefined),
+    ]));
+}
+export function generateSdkType(config, state) {
+    const properties = [];
+    if (state.hasQueries) {
+        properties.push(generateSdkPropertySignature(config.sdk.queriesKey, config.sdk.operationRequestsTypeNameBuilder('QUERY')));
+    }
+    if (state.hasMutations) {
+        properties.push(generateSdkPropertySignature(config.sdk.mutationsKey, config.sdk.operationRequestsTypeNameBuilder('MUTATION')));
+    }
+    if (state.hasSubscriptions) {
+        properties.push(generateSdkPropertySignature(config.sdk.subscriptionsKey, config.sdk.operationRequestsTypeNameBuilder('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'), undefined, undefined),
+    ], undefined, properties);
+}

package/actors/ts/gql-client/generators/help-nodes/subscription-method-func-alias.d.ts

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

package/actors/ts/gql-client/generators/help-nodes/subscription-method-func-alias.js

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+export function generateSubscriptionMethodFuncAlias(config) {
+    return ts.factory.createTypeAliasDeclaration(undefined, ts.factory.createIdentifier(config.sdk.gqlSubscriptionMethodFuncTypeName), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), undefined, undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('V'), undefined, undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('R'), undefined, undefined),
+    ], ts.factory.createFunctionTypeNode(undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('variables'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('V'), undefined), undefined),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('context'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('TRequestContext'), undefined), undefined),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('controller'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('AbortController'), undefined), undefined),
+    ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode('types.SubOpAsyncIterable', [ts.factory.createTypeReferenceNode('R')]),
+    ])));
+}

package/actors/ts/gql-client/generators/help-nodes/sync-method-func-alias.d.ts

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

package/actors/ts/gql-client/generators/help-nodes/sync-method-func-alias.js

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+export function generateSyncMethodFuncAlias(config) {
+    return ts.factory.createTypeAliasDeclaration(undefined, ts.factory.createIdentifier(config.sdk.gqlSyncMethodFuncTypeName), [
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('TRequestContext'), undefined, undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('V'), undefined, undefined),
+        ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier('R'), undefined, undefined),
+    ], ts.factory.createFunctionTypeNode(undefined, [
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('variables'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('V'), undefined), undefined),
+        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('context'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('TRequestContext'), undefined), undefined),
+    ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('R'), undefined),
+    ])));
+}

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

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

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

@@ -1,65 +1,31 @@
 import ts from 'typescript';
-function generateFunctionBlock(operationName, operationType, returnType) {
-    const callArgs = [
-        ts.factory.createIdentifier(operationName),
-        ts.factory.createIdentifier('variables'),
-        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));
-    if (returnType === 'ExecuteResult') {
-        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')),
-    ], true);
-}
-function createReturnTypeNode(resultName, returnType, operationType) {
-    const rOpType = ts.factory.createTypeReferenceNode(resultName);
-    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);
-}
+import { createBuildSubscriptionCallbackFunctionName } from './help-nodes/build-subscription-callback-function.js';
+import { createBuildSyncCallbackFunctionName } from './help-nodes/build-sync-callback-function.js';
+import { generateHelpNodes } from './help-nodes/index.js';
+import { getReturnTypeFromConfig } from './operation-return-type.js';
 export function generateNodes(config, context) {
     const graphqlImports = [];
-    let shouldIncludeExecuteResultType = false;
     const queryNodes = [];
     const mutationNodes = [];
     const subscriptionNodes = [];
     for (const operation of Object.values(context.schema.client.operations)) {
-        const operationName = operation.name + 'Operation';
-        const variablesName = operation.name + 'Variables';
-        const resultName = operation.name + 'Result';
-        graphqlImports.push(operationName, variablesName, resultName);
-        const returnType = getReturnTypeFromConfig(config, operation.name);
-        if (returnType === 'ExecuteResult')
-            shouldIncludeExecuteResultType = true;
-        const funcArgs = [
-            ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, ts.factory.createTypeReferenceNode(variablesName)),
-            ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')),
-        ];
-        if (operation.type === 'SUBSCRIPTION') {
-            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),
-        ]), ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), generateFunctionBlock(operationName, operation.type, returnType)));
+        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)));
+        const operationReturnType = getReturnTypeFromConfig(config, operation.name);
+        const functionName = operation.type === 'SUBSCRIPTION'
+            ? createBuildSubscriptionCallbackFunctionName(operationReturnType)
+            : createBuildSyncCallbackFunctionName(operationReturnType);
+        const propAssignment = ts.factory.createPropertyAssignment(operation.name, ts.factory.createCallExpression(ts.factory.createIdentifier(functionName), [
+            ts.factory.createTypeReferenceNode('TExecutor', undefined),
+            ts.factory.createTypeReferenceNode('TRequestContext', undefined),
+            ts.factory.createTypeReferenceNode(variablesName, undefined),
+            ts.factory.createTypeReferenceNode(resultName, undefined),
+        ], [
+            ts.factory.createIdentifier('executor'),
+            ts.factory.createIdentifier(operationName),
+        ]));
         switch (operation.type) {
             case 'QUERY': {
                 queryNodes.push(propAssignment);
@@ -76,36 +42,40 @@ 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('types')),
     ];
-    if (shouldIncludeExecuteResultType) {
-        gqlClientImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('ExecuteResult')));
-    }
     const returnObjectNodes = [];
-    if (queryNodes.length !== 0) {
+    const state = {
+        hasQueries: queryNodes.length !== 0,
+        hasMutations: mutationNodes.length !== 0,
+        hasSubscriptions: subscriptionNodes.length !== 0,
+    };
+    if (state.hasQueries) {
         returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.queriesKey, ts.factory.createObjectLiteralExpression(queryNodes, true)));
     }
-    if (mutationNodes.length !== 0) {
+    if (state.hasMutations) {
         returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.mutationsKey, ts.factory.createObjectLiteralExpression(mutationNodes, true)));
     }
-    if (subscriptionNodes.length !== 0) {
-        gqlClientImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('SubOpAsyncIterable')));
+    if (state.hasSubscriptions) {
         returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.subscriptionsKey, ts.factory.createObjectLiteralExpression(subscriptionNodes, true)));
     }
     return [
-        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([], ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports(gqlClientImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client')),
+        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, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext')),
-        ], [
-            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
+            ts.factory.createTypeParameterDeclaration(undefined, 'TExecutor', ts.factory.createTypeReferenceNode('types.IExecutor', [
                 ts.factory.createTypeReferenceNode('TRequestContext'),
             ])),
-        ], undefined, ts.factory.createBlock([
+            ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('types.RequestContext')),
+        ], [
+            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('TExecutor')),
+        ], ts.factory.createTypeReferenceNode('SdkType', [
+            ts.factory.createTypeReferenceNode('TRequestContext'),
+        ]), ts.factory.createBlock([
             ts.factory.createReturnStatement(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression(returnObjectNodes, true), ts.factory.createTypeReferenceNode('const'))),
         ], true)),
     ];

package/actors/ts/gql-client/generators/operation-function-block.d.ts

@@ -0,0 +1,3 @@
+import { OperationReturnType } from '../actor.js';
+import ts from 'typescript';
+export declare function generateFunctionBlock(isSubscription: boolean, returnType: OperationReturnType): ts.Block;

package/actors/ts/gql-client/generators/operation-function-block.js

@@ -0,0 +1,21 @@
+import ts from 'typescript';
+export function generateFunctionBlock(isSubscription, returnType) {
+    const callArgs = [
+        ts.factory.createIdentifier('operation'),
+        ts.factory.createIdentifier('variables'),
+        ts.factory.createIdentifier('requestContext'),
+    ];
+    if (isSubscription) {
+        callArgs.push(ts.factory.createIdentifier('controller'));
+    }
+    const awaitExpression = ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('executor'), isSubscription ? 'executeSubscription' : 'executeSync'), undefined, callArgs));
+    if (returnType === 'ExecuteResult') {
+        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')),
+    ], true);
+}

package/actors/ts/gql-client/generators/operation-return-type.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+import { Config, OperationReturnType } from '../actor.js';
+export declare function createReturnTypeNode(resultName: string, returnType: OperationReturnType, isSubscription: boolean): ts.TypeReferenceNode;
+export declare function getReturnTypeFromConfig(config: Config, operationName: string): OperationReturnType;