@vladimirdev635/gql-codegen 0.0.107 → 0.0.109

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

@@ -1,3 +1,3 @@
 import { Formatter } from '../../shared.js';
 import { LoadESLintFuncType } from './types.js';
-export declare function buildESLintFormatter(loadFunc: LoadESLintFuncType): Promise<Formatter>;
+export declare function build(loadFunc: LoadESLintFuncType): Promise<Formatter>;

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

@@ -1,5 +1,5 @@
 import assert from 'assert';
-export async function buildESLintFormatter(loadFunc) {
+export async function build(loadFunc) {
     const ESLint = await loadFunc({ useFlatConfig: true });
     const eslint = new ESLint({ fix: true });
     return async (code) => {

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

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

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

@@ -1 +1 @@
-export { buildESLintFormatter } from './formatter.js';
+export { build } from './formatter.js';

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

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

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

@@ -1,4 +1,4 @@
-export async function buildOxfmtFormatter(formatFunc, options) {
+export async function build(formatFunc, options) {
     return async (code) => {
         const result = await formatFunc('[buffer].ts', code, options);
         for (const error of result.errors) {

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

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

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

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

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

@@ -10,10 +10,10 @@ export interface SDKConfig {
     mutationsKey: string;
     subscriptionsKey: string;
 }
-export interface GQLClientActorConfig extends TSActorConfig {
+export interface Config extends TSActorConfig {
     outPath: PathOrFileDescriptor;
     importDeclarations: ts.ImportDeclaration[];
     sdk: SDKConfig;
     graphqlModulePath: string;
 }
-export declare function buildGQLClientActor(config: GQLClientActorConfig): Actor<ActorContext>;
+export declare function build(config: Config): Actor<ActorContext>;

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

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

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

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

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

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

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

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

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

@@ -2,7 +2,7 @@ import { PathOrFileDescriptor } from 'fs';
 import { Actor, ActorContext } from '../../../config.js';
 import { TSActorConfig } from '../shared.js';
 import ts from 'typescript';
-export interface GQLClientReactActorConfig extends TSActorConfig {
+export interface Config extends TSActorConfig {
     outPath: PathOrFileDescriptor;
     importDeclarations: ts.ImportDeclaration[];
     graphqlModulePath: string;
@@ -12,4 +12,4 @@ export interface GQLClientReactActorConfig extends TSActorConfig {
         subscriptionsKey: string;
     };
 }
-export declare function buildGQLClientReactActor(config: GQLClientReactActorConfig): Actor<ActorContext>;
+export declare function build(config: Config): Actor<ActorContext>;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+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;
+    };
+}
+export declare function build(config: Config): Actor<ActorContext>;

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

@@ -0,0 +1,11 @@
+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);
+}
+export function build(config) {
+    return (context) => actor(config, context);
+}

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

@@ -0,0 +1,4 @@
+import { ActorContext } from '../../../../config.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-vue/generators/main.js

@@ -0,0 +1,135 @@
+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)),
+    ];
+}

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

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

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

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

package/actors/ts/index.d.ts

@@ -1,5 +1,6 @@
 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 graphql from './graphql/index.js';
 export { type Formatter, type TSActorConfig, renderNodes, loadTsConfigCompilerOptions, addNewLineBetweenNodes, invokeMethod, } from './shared.js';
 export { generateImportDeclaration } from './utils.js';

package/actors/ts/index.js

@@ -1,5 +1,6 @@
 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 graphql from './graphql/index.js';
 export { renderNodes, loadTsConfigCompilerOptions, addNewLineBetweenNodes, invokeMethod, } from './shared.js';
 export { generateImportDeclaration } from './utils.js';

package/package.json

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

package/schema/utils.d.ts

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

package/schema/utils.js

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