@vladimirdev635/gql-codegen 0.0.109 → 0.0.111

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/actors/utils.d.ts

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

package/actors/utils.js

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

package/config.d.ts

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

package/config.js

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

package/index.d.ts

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

package/index.js

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

package/main.d.ts

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

package/main.js

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

package/package.json

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

package/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/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[];

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

@@ -1,121 +0,0 @@
-import ts from 'typescript';
-function generateFunctionBlock(operationName, type) {
-    switch (type) {
-        case 'SYNC':
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('useOperation'), undefined, [
-                ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName),
-                ts.factory.createIdentifier('variables'),
-                ts.factory.createIdentifier('requestContext'),
-            ]);
-        case 'LAZY':
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('useLazyOperation'), undefined, [
-                ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName),
-            ]);
-        case 'SUBSCRIPTION':
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('useSubscription'), undefined, [
-                ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName),
-                ts.factory.createIdentifier('variables'),
-                ts.factory.createIdentifier('requestContext'),
-            ]);
-    }
-}
-function generateArrowFunction(operationName, variablesName, resultName, type) {
-    const parameters = [];
-    let resultType;
-    switch (type) {
-        case 'LAZY':
-            resultType = ts.factory.createTypeReferenceNode('UseLazyOperationReturnType', [
-                ts.factory.createTypeReferenceNode(variablesName),
-                ts.factory.createTypeReferenceNode(resultName),
-                ts.factory.createTypeReferenceNode('TRequestContext'),
-            ]);
-            break;
-        case 'SYNC': {
-            resultType = ts.factory.createTypeReferenceNode('OperationState', [
-                ts.factory.createTypeReferenceNode(resultName),
-            ]);
-            parameters.push(ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, ts.factory.createTypeReferenceNode(variablesName)), ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')));
-            break;
-        }
-        case 'SUBSCRIPTION': {
-            resultType = ts.factory.createTypeReferenceNode('OperationState', [
-                ts.factory.createTypeReferenceNode('SubOpAsyncIterable', [
-                    ts.factory.createTypeReferenceNode(resultName),
-                ]),
-            ]);
-            parameters.push(ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, ts.factory.createTypeReferenceNode(variablesName)), ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, ts.factory.createTypeReferenceNode('TRequestContext')));
-            break;
-        }
-    }
-    return ts.factory.createArrowFunction(undefined, undefined, parameters, resultType, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), generateFunctionBlock(operationName, type));
-}
-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 = operation.name + 'Operation';
-        const variablesName = operation.name + 'Variables';
-        const resultName = operation.name + 'Result';
-        graphqlImports.push(operationName, variablesName, resultName);
-        switch (operation.type) {
-            case 'SUBSCRIPTION': {
-                subscriptionNodes.push(ts.factory.createPropertyAssignment('use' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'SUBSCRIPTION')));
-                break;
-            }
-            case 'MUTATION': {
-                mutationNodes.push(ts.factory.createPropertyAssignment('use' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'LAZY')));
-                break;
-            }
-            case 'QUERY': {
-                queryNodes.push(ts.factory.createPropertyAssignment('use' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'SYNC')), ts.factory.createPropertyAssignment('useLazy' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'LAZY')));
-                break;
-            }
-        }
-    }
-    const gqlClientReactImports = [
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useOperation')),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useLazyOperation')),
-        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('OperationState')),
-        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseLazyOperationReturnType')),
-    ];
-    const gqlClientImports = [
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('IExecutor')),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('RequestContext')),
-    ];
-    if (subscriptionNodes.length !== 0) {
-        gqlClientReactImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useSubscription')));
-        gqlClientImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('SubOpAsyncIterable')));
-    }
-    const returnObjectNodes = [];
-    if (queryNodes.length !== 0) {
-        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.queriesKey, ts.factory.createObjectLiteralExpression(queryNodes, true)));
-    }
-    if (mutationNodes.length !== 0) {
-        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.mutationsKey, ts.factory.createObjectLiteralExpression(mutationNodes, true)));
-    }
-    if (subscriptionNodes.length !== 0) {
-        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(false, undefined, ts.factory.createNamedImports(gqlClientReactImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client-react')),
-        ts.factory.createImportDeclaration([], ts.factory.createImportClause(true, undefined, ts.factory.createNamedImports(gqlClientImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client/types')),
-        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(graphqlImports.map((i) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(config.graphqlModulePath)),
-        ts.factory.createIdentifier('\n'),
-        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [
-            ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext')),
-        ], [
-            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
-                ts.factory.createTypeReferenceNode('TRequestContext'),
-            ])),
-        ], undefined, ts.factory.createBlock([
-            ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(returnObjectNodes, true)),
-        ], true)),
-    ];
-}

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

@@ -1,135 +0,0 @@
-import ts from 'typescript';
-function generateFunctionBlock(operationName, type) {
-    switch (type) {
-        case 'SYNC':
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('useOperation'), undefined, [
-                ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName),
-                ts.factory.createIdentifier('variables'),
-                ts.factory.createIdentifier('requestContext'),
-            ]);
-        case 'LAZY':
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('useLazyOperation'), undefined, [
-                ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName),
-            ]);
-        case 'SUBSCRIPTION':
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('useSubscription'), undefined, [
-                ts.factory.createIdentifier('executor'),
-                ts.factory.createIdentifier(operationName),
-                ts.factory.createIdentifier('variables'),
-                ts.factory.createIdentifier('requestContext'),
-            ]);
-    }
-}
-function createTypeOrRefTypeNode(innerType) {
-    return ts.factory.createUnionTypeNode([
-        innerType,
-        ts.factory.createTypeReferenceNode('Ref', [innerType]),
-    ]);
-}
-function generateArrowFunction(operationName, variablesName, resultName, type) {
-    const parameters = [];
-    let resultType;
-    switch (type) {
-        case 'LAZY':
-            resultType = ts.factory.createTypeReferenceNode('UseLazyOperationReturnType', [
-                ts.factory.createTypeReferenceNode(variablesName),
-                ts.factory.createTypeReferenceNode(resultName),
-                ts.factory.createTypeReferenceNode('TRequestContext'),
-            ]);
-            break;
-        case 'SYNC': {
-            resultType = ts.factory.createTypeReferenceNode('ShallowRef', [
-                ts.factory.createTypeReferenceNode('OperationState', [
-                    ts.factory.createTypeReferenceNode(resultName),
-                ]),
-            ]);
-            parameters.push(ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, createTypeOrRefTypeNode(ts.factory.createTypeReferenceNode(variablesName))), ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, createTypeOrRefTypeNode(ts.factory.createTypeReferenceNode('TRequestContext'))));
-            break;
-        }
-        case 'SUBSCRIPTION': {
-            resultType = ts.factory.createTypeReferenceNode('ShallowRef', [
-                ts.factory.createTypeReferenceNode('OperationState', [
-                    ts.factory.createTypeReferenceNode('SubOpAsyncIterable', [
-                        ts.factory.createTypeReferenceNode(resultName),
-                    ]),
-                ]),
-            ]);
-            parameters.push(ts.factory.createParameterDeclaration(undefined, undefined, 'variables', undefined, createTypeOrRefTypeNode(ts.factory.createTypeReferenceNode(variablesName))), ts.factory.createParameterDeclaration(undefined, undefined, 'requestContext', undefined, createTypeOrRefTypeNode(ts.factory.createTypeReferenceNode('TRequestContext'))));
-            break;
-        }
-    }
-    return ts.factory.createArrowFunction(undefined, undefined, parameters, resultType, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), generateFunctionBlock(operationName, type));
-}
-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 = operation.name + 'Operation';
-        const variablesName = operation.name + 'Variables';
-        const resultName = operation.name + 'Result';
-        graphqlImports.push(operationName, variablesName, resultName);
-        switch (operation.type) {
-            case 'SUBSCRIPTION': {
-                subscriptionNodes.push(ts.factory.createPropertyAssignment('use' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'SUBSCRIPTION')));
-                break;
-            }
-            case 'MUTATION': {
-                mutationNodes.push(ts.factory.createPropertyAssignment('use' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'LAZY')));
-                break;
-            }
-            case 'QUERY': {
-                queryNodes.push(ts.factory.createPropertyAssignment('use' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'SYNC')), ts.factory.createPropertyAssignment('useLazy' + operation.name, generateArrowFunction(operationName, variablesName, resultName, 'LAZY')));
-                break;
-            }
-        }
-    }
-    const gqlClientVueImports = [
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useOperation')),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useLazyOperation')),
-        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('OperationState')),
-        ts.factory.createImportSpecifier(true, undefined, ts.factory.createIdentifier('UseLazyOperationReturnType')),
-    ];
-    const gqlClientImports = [
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('IExecutor')),
-        ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('RequestContext')),
-    ];
-    if (subscriptionNodes.length !== 0) {
-        gqlClientVueImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('useSubscription')));
-        gqlClientImports.push(ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('SubOpAsyncIterable')));
-    }
-    const returnObjectNodes = [];
-    if (queryNodes.length !== 0) {
-        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.queriesKey, ts.factory.createObjectLiteralExpression(queryNodes, true)));
-    }
-    if (mutationNodes.length !== 0) {
-        returnObjectNodes.push(ts.factory.createPropertyAssignment(config.sdk.mutationsKey, ts.factory.createObjectLiteralExpression(mutationNodes, true)));
-    }
-    if (subscriptionNodes.length !== 0) {
-        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(false, undefined, ts.factory.createNamedImports([
-            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('Ref')),
-            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier('ShallowRef')),
-        ])), ts.factory.createStringLiteral('vue')),
-        ts.factory.createImportDeclaration([], ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports(gqlClientVueImports)), ts.factory.createStringLiteral('@vladimirdev635/gql-client-vue')),
-        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.createIdentifier('\n'),
-        ts.factory.createFunctionDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), undefined, 'createSdk', [
-            ts.factory.createTypeParameterDeclaration(undefined, 'TRequestContext', ts.factory.createTypeReferenceNode('RequestContext')),
-        ], [
-            ts.factory.createParameterDeclaration(undefined, undefined, 'executor', undefined, ts.factory.createTypeReferenceNode('IExecutor', [
-                ts.factory.createTypeReferenceNode('TRequestContext'),
-            ])),
-        ], undefined, ts.factory.createBlock([
-            ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(returnObjectNodes, true)),
-        ], true)),
-    ];
-}