@vladimirdev635/gql-codegen 0.0.97 → 0.0.98

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

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 export function generateEnumDefinition(e) {
-    return ts.factory.createEnumDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), e.name, e.values.map(value => ts.factory.createEnumMember(value, ts.factory.createStringLiteral(value))));
+    return ts.factory.createEnumDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), e.name, e.values.map((value) => ts.factory.createEnumMember(value, ts.factory.createStringLiteral(value))));
 }

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

@@ -8,7 +8,8 @@ function generateZodInputTypeSpec(scalarsMapping, type) {
             return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'enum'), undefined, [ts.factory.createIdentifier(type.name)]);
         }
         case 'Scalar': {
-            return getScalarSpecFromMapping(scalarsMapping, type.name).inputSchema;
+            return getScalarSpecFromMapping(scalarsMapping, type.name)
+                .inputSchema;
         }
         case 'InputType': {
             return ts.factory.createIdentifier(generateSchemaName(type.name));
@@ -34,30 +35,32 @@ function generateZodInputField(scalarsMapping, field) {
 }
 function isFieldLazy(spec) {
     switch (spec._type) {
-        case 'literal': return spec.type._type === 'InputType';
-        case 'array': return isFieldLazy(spec.type);
+        case 'literal':
+            return spec.type._type === 'InputType';
+        case 'array':
+            return isFieldLazy(spec.type);
     }
 }
 export function generateInputTypeDefinitionFields(scalarsMapping, fields) {
     return Object.entries(fields).map(([name, field]) => {
         const fieldSpec = generateZodInputField(scalarsMapping, field);
         if (isFieldLazy(field.spec)) {
-            return ts.factory.createGetAccessorDeclaration([], name, [], undefined, ts.factory.createBlock([
-                ts.factory.createReturnStatement(fieldSpec)
-            ], true));
+            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) {
     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.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.NodeFlags.Const));
 }
 export function generateInputTypeDefinitions(scalarsMapping, input) {
     return [
         generateZodInputTypeDefinition(scalarsMapping, input.name, input.fields),
         generateZodInferTypeAlias('input', input.name, generateSchemaName(input.name)),
-        ts.factory.createIdentifier('\n')
+        ts.factory.createIdentifier('\n'),
     ];
 }

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

@@ -6,17 +6,20 @@ import { addNewLineBetweenNodes } from '../../../shared.js';
 import { generateObjectTypeNodes } from './objects.js';
 export function generateServerNodes(config, context) {
     return [
-        ...addNewLineBetweenNodes(Object.values(context.schema.server.enums)
-            .map(generateEnumDefinition)),
+        ...addNewLineBetweenNodes(Object.values(context.schema.server.enums).map(generateEnumDefinition)),
         ts.factory.createIdentifier('\n'),
-        ...!config.onlyRequiredForOperations ?
-            Object.values(context.schema.server.objects)
-                .map(object => generateObjectTypeNodes(config.scalarsMapping, object)).flat() : [],
-        ...!config.onlyRequiredForOperations ?
-            Object.values(context.schema.server.unions)
-                .map(union => generateUnionTypeDefinitions(config.scalarsMapping, context.schema.server.objects, union)).flat() : [],
+        ...(!config.onlyRequiredForOperations
+            ? Object.values(context.schema.server.objects)
+                .map((object) => generateObjectTypeNodes(config.scalarsMapping, object))
+                .flat()
+            : []),
+        ...(!config.onlyRequiredForOperations
+            ? Object.values(context.schema.server.unions)
+                .map((union) => generateUnionTypeDefinitions(config.scalarsMapping, context.schema.server.objects, union))
+                .flat()
+            : []),
         ...Object.values(context.schema.server.inputs)
-            .map(input => generateInputTypeDefinitions(config.scalarsMapping, input))
-            .flat()
+            .map((input) => generateInputTypeDefinitions(config.scalarsMapping, input))
+            .flat(),
     ];
 }

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

@@ -10,7 +10,8 @@ function generateZodObjectTypeSpec(scalarsMapping, type) {
             return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'enum'), undefined, [ts.factory.createIdentifier(type.name)]);
         }
         case 'Scalar': {
-            return getScalarSpecFromMapping(scalarsMapping, type.name).outputSchema;
+            return getScalarSpecFromMapping(scalarsMapping, type.name)
+                .outputSchema;
         }
         case 'Union':
         case 'InterfaceType':
@@ -63,9 +64,12 @@ const lazyTypes = [
 ];
 function isFieldLazy(spec) {
     switch (spec._type) {
-        case 'literal': return lazyTypes.includes(spec.type._type);
-        case 'array': return isFieldLazy(spec.type);
-        case 'callable': return isFieldLazy(spec.returnType);
+        case 'literal':
+            return lazyTypes.includes(spec.type._type);
+        case 'array':
+            return isFieldLazy(spec.type);
+        case 'callable':
+            return isFieldLazy(spec.returnType);
     }
 }
 function generateObjectTypeDefinitionFields(scalarsMapping, fields, typename) {
@@ -78,26 +82,26 @@ function generateObjectTypeDefinitionFields(scalarsMapping, fields, typename) {
         ...Object.entries(fields).map(([name, field]) => {
             const fieldSpec = generateZodObjectFieldSpec(scalarsMapping, field);
             if (isFieldLazy(field.spec)) {
-                return ts.factory.createGetAccessorDeclaration([], name, [], undefined, ts.factory.createBlock([
-                    ts.factory.createReturnStatement(fieldSpec)
-                ], true));
+                return ts.factory.createGetAccessorDeclaration([], name, [], undefined, ts.factory.createBlock([ts.factory.createReturnStatement(fieldSpec)], true));
             }
             return ts.factory.createPropertyAssignment(name, fieldSpec);
-        })
+        }),
     ];
 }
 export function generateZodObjectTypeExpression(scalarsMapping, object, includeTypename = false) {
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('object')), undefined, [ts.factory.createObjectLiteralExpression(generateObjectTypeDefinitionFields(scalarsMapping, object.fields, includeTypename ? object.name : undefined), true)]);
+    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('object')), undefined, [
+        ts.factory.createObjectLiteralExpression(generateObjectTypeDefinitionFields(scalarsMapping, object.fields, includeTypename ? object.name : undefined), true),
+    ]);
 }
 export function generateZodObjectTypeNode(scalarsMapping, object) {
     return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(generateSchemaName(object.name), undefined, undefined, generateZodObjectTypeExpression(scalarsMapping, object))
+        ts.factory.createVariableDeclaration(generateSchemaName(object.name), undefined, undefined, generateZodObjectTypeExpression(scalarsMapping, object)),
     ], ts.NodeFlags.Const));
 }
 export function generateObjectTypeNodes(scalarsMapping, object) {
     return [
         generateZodObjectTypeNode(scalarsMapping, object),
         generateZodInferTypeAlias('output', object.name, generateSchemaName(object.name)),
-        ts.factory.createIdentifier('\n')
+        ts.factory.createIdentifier('\n'),
     ];
 }

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

@@ -8,18 +8,36 @@ export const additionalScalarsMapping = {
     UUID: builtinScalarsMapping.String,
     Datetime: {
         inputSchema: invokeMethod(ts.factory.createIdentifier('z'), 'date', []),
-        outputSchema: invokeMethod(invokeMethod(ts.factory.createIdentifier('z'), 'string', []), 'transform', [ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'v')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), [], [ts.factory.createIdentifier('v')]))])
+        outputSchema: invokeMethod(invokeMethod(ts.factory.createIdentifier('z'), 'string', []), 'transform', [
+            ts.factory.createArrowFunction(undefined, undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, 'v'),
+            ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), [], [ts.factory.createIdentifier('v')])),
+        ]),
     },
     Upload: buildSymmetricScalarSpec(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'file'), undefined, [])),
     Url: {
-        inputSchema: invokeMethod(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'custom'), [ts.factory.createTypeReferenceNode('URL')], []), 'transform', [ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'url')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), invokeMethod(ts.factory.createIdentifier('url'), 'toString', []))]),
-        outputSchema: invokeMethod(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'string'), [], []), 'transform', [ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'v')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('URL'), undefined, [ts.factory.createIdentifier('v')]))]),
+        inputSchema: invokeMethod(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'custom'), [ts.factory.createTypeReferenceNode('URL')], []), 'transform', [
+            ts.factory.createArrowFunction(undefined, undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, 'url'),
+            ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), invokeMethod(ts.factory.createIdentifier('url'), 'toString', [])),
+        ]),
+        outputSchema: invokeMethod(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'string'), [], []), 'transform', [
+            ts.factory.createArrowFunction(undefined, undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, 'v'),
+            ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('URL'), undefined, [ts.factory.createIdentifier('v')])),
+        ]),
     },
     Void: buildSymmetricScalarSpec(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'any'), undefined, [])),
     Date: {
         inputSchema: invokeMethod(invokeMethod(ts.factory.createIdentifier('z'), 'date', []), 'transform', [
-            ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'v')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createElementAccessExpression(invokeMethod(invokeMethod(ts.factory.createIdentifier('v'), 'toISOString', []), 'split', [ts.factory.createStringLiteral('T')]), ts.factory.createNumericLiteral(0)))
+            ts.factory.createArrowFunction(undefined, undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, 'v'),
+            ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createElementAccessExpression(invokeMethod(invokeMethod(ts.factory.createIdentifier('v'), 'toISOString', []), 'split', [ts.factory.createStringLiteral('T')]), ts.factory.createNumericLiteral(0))),
+        ]),
+        outputSchema: invokeMethod(invokeMethod(ts.factory.createIdentifier('z'), 'string', []), 'transform', [
+            ts.factory.createArrowFunction(undefined, undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, 'v'),
+            ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), [], [ts.factory.createIdentifier('v')])),
         ]),
-        outputSchema: invokeMethod(invokeMethod(ts.factory.createIdentifier('z'), 'string', []), 'transform', [ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'v')], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createNewExpression(ts.factory.createIdentifier('Date'), [], [ts.factory.createIdentifier('v')]))])
     },
 };

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

@@ -1,3 +1,3 @@
 export { builtinScalarsMapping } from './builtin.js';
-export { type BuiltinScalarName, type ScalarSpec, type ScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping } from './mapping.js';
+export { type BuiltinScalarName, type ScalarSpec, type ScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping, } from './mapping.js';
 export { additionalScalarsMapping } from './additional.js';

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

@@ -1,3 +1,3 @@
 export { builtinScalarsMapping } from './builtin.js';
-export { buildSymmetricScalarSpec, getScalarSpecFromMapping } from './mapping.js';
+export { buildSymmetricScalarSpec, getScalarSpecFromMapping, } from './mapping.js';
 export { additionalScalarsMapping } from './additional.js';

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

@@ -1,7 +1,7 @@
 export function buildSymmetricScalarSpec(specType) {
     return {
         inputSchema: specType,
-        outputSchema: specType
+        outputSchema: specType,
     };
 }
 export function getScalarSpecFromMapping(scalarsMapping, name) {

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

@@ -9,12 +9,14 @@ export function generateNonCallableFieldSpec(scalars, spec) {
     }
 }
 export function wrapInMaybeIfNullable(spec, nullable) {
-    return nullable ?
-        ts.factory.createTypeReferenceNode('Maybe', [spec]) :
-        spec;
+    return nullable
+        ? ts.factory.createTypeReferenceNode('Maybe', [spec])
+        : spec;
 }
 export function generateZodInferTypeAlias(inferType, name, typeName) {
-    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), name, undefined, ts.factory.createTypeReferenceNode('z.' + inferType, [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(typeName), undefined)]));
+    return ts.factory.createTypeAliasDeclaration(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), name, undefined, ts.factory.createTypeReferenceNode('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

@@ -3,16 +3,16 @@ import { generateSchemaName, generateZodInferTypeAlias } 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([
-        ts.factory.createVariableDeclaration(generateSchemaName(union.name), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('discriminatedUnion')), undefined, [ts.factory.createStringLiteral(union.name),
-            ts.factory.createArrayLiteralExpression(Object.keys(union.items)
-                .map(item => generateZodObjectTypeExpression(scalarsMapping, objects[item], true)), true)
-        ]))
+        ts.factory.createVariableDeclaration(generateSchemaName(union.name), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('discriminatedUnion')), undefined, [
+            ts.factory.createStringLiteral(union.name),
+            ts.factory.createArrayLiteralExpression(Object.keys(union.items).map((item) => generateZodObjectTypeExpression(scalarsMapping, objects[item], true)), true),
+        ])),
     ], ts.NodeFlags.Const));
 }
 export function generateUnionTypeDefinitions(scalarsMapping, objects, union) {
     return [
         generateZodUnionTypeNode(scalarsMapping, objects, union),
         generateZodInferTypeAlias('output', union.name, generateSchemaName(union.name)),
-        ts.factory.createIdentifier('\n')
+        ts.factory.createIdentifier('\n'),
     ];
 }

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

@@ -1,8 +1,8 @@
 import ts from 'typescript';
 export function createQuestionTokenIfNullable(nullable) {
-    return nullable ?
-        ts.factory.createToken(ts.SyntaxKind.QuestionToken) :
-        undefined;
+    return nullable
+        ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+        : undefined;
 }
 export function createTypenamePropertySignature(name, optional, alias) {
     return ts.factory.createPropertySignature(undefined, alias || '__typename', createQuestionTokenIfNullable(optional), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(name)));
@@ -18,7 +18,7 @@ export function generateTypeReferenceNode(scalars, name) {
 export function generateStringOrTemplate(value, values) {
     if (values.length === 0)
         return ts.factory.createStringLiteral(value);
-    return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(value), values.map((item, index) => ts.factory.createTemplateSpan(ts.factory.createIdentifier(item), index + 1 !== values.length ?
-        ts.factory.createTemplateMiddle('', '') :
-        ts.factory.createTemplateTail('', ''))));
+    return ts.factory.createTemplateExpression(ts.factory.createTemplateHead(value), values.map((item, index) => ts.factory.createTemplateSpan(ts.factory.createIdentifier(item), index + 1 !== values.length
+        ? ts.factory.createTemplateMiddle('', '')
+        : ts.factory.createTemplateTail('', ''))));
 }

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

@@ -1,2 +1,2 @@
 export { buildGraphqlActor, GraphqlActorConfig } from './actor.js';
-export { builtinScalarsMapping, additionalScalarsMapping, type BuiltinScalarName, type ScalarSpec, type ScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping } from './generators/server/scalars/index.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 { builtinScalarsMapping, additionalScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping } from './generators/server/scalars/index.js';
+export { builtinScalarsMapping, additionalScalarsMapping, buildSymmetricScalarSpec, getScalarSpecFromMapping, } from './generators/server/scalars/index.js';

package/actors/ts/utils.js

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 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.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));
 }

package/config.d.ts

@@ -1,8 +1,6 @@
 import { RootSchema } from './schema/root.js';
-import { Logger } from 'pino';
 export interface ActorContext {
     readonly schema: RootSchema;
-    readonly logger: Logger;
 }
 export type Actor<T extends ActorContext> = (c: T) => Promise<void> | void;
 export interface Config<T extends ActorContext> {

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -1,43 +1,45 @@
 {
     "name": "@vladimirdev635/gql-codegen",
-    "version": "0.0.97",
-    "type": "module",
-    "main": "./index.js",
-    "types": "./index.d.ts",
-    "files": [
-        "./"
-    ],
+    "version": "0.0.98",
+    "description": "",
+    "keywords": [],
     "homepage": "https://github.com/Voldemat/graphql-plus-plus#readme",
+    "license": "ISC",
+    "author": "",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/Voldemat/graphql-plus-plus.git"
     },
+    "files": [
+        "./"
+    ],
+    "type": "module",
+    "main": "./index.js",
+    "types": "./index.d.ts",
     "scripts": {
-        "lint": "eslint .",
-        "lint:fix": "eslint --fix .",
-        "lint:ci": "npm run lint",
+        "fmt": "oxfmt .",
+        "fmt:check": "oxfmt --check .",
+        "lint": "oxlint .",
+        "lint:fix": "oxlint --fix .",
+        "lint:ci": "npm run fmt:check && npm run lint",
         "test": "vitest",
         "build": "tsc && tsc-alias && cp package.json ./dist/package.json"
     },
-    "keywords": [],
-    "author": "",
-    "license": "ISC",
-    "description": "",
     "devDependencies": {
-        "@babel/eslint-parser": "^7.27.5",
-        "@babel/plugin-transform-typescript": "^7.27.1",
-        "@eslint/compat": "^1.3.0",
         "@types/node": "^24.0.1",
-        "@typescript-eslint/eslint-plugin": "^8.34.0",
         "assert": "^2.1.0",
-        "eslint": "^9.28.0",
         "jiti": "^2.4.2",
+        "oxfmt": "^0.62.0",
+        "oxlint": "^1.77.0",
         "tsc-alias": "^1.8.16",
         "vitest": "^3.2.4"
     },
     "peerDependencies": {
-        "pino": ">=9.7.0",
-        "typescript": ">=5.8.3",
+        "typescript": ">=5.8.3 <7.0.0",
         "zod": ">=3.25.76"
+    },
+    "allowScripts": {
+        "esbuild@0.28.1": true,
+        "fsevents@2.3.3": true
     }
 }

package/schema/client/argument.d.ts

@@ -5,7 +5,7 @@ export declare const argumentValue: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     _type: z.ZodLiteral<"literal">;
     value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-}, z.core.$strip>]>;
+}, z.core.$strip>], "_type">;
 export declare const argument: z.ZodObject<{
     name: z.ZodString;
     value: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -14,5 +14,5 @@ export declare const argument: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         _type: z.ZodLiteral<"literal">;
         value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>], "_type">;
 }, z.core.$strip>;

package/schema/client/argument.js

@@ -2,12 +2,12 @@ import { z } from 'zod/v4';
 export const argumentValue = z.discriminatedUnion('_type', [
     z.object({
         _type: z.literal('ref'),
-        name: z.string()
+        name: z.string(),
     }),
     z.object({
         _type: z.literal('literal'),
-        value: z.union([z.string(), z.number(), z.boolean()])
-    })
+        value: z.union([z.string(), z.number(), z.boolean()]),
+    }),
 ]);
 export const argument = z.object({
     name: z.string(),

package/schema/client/directive.d.ts

@@ -16,14 +16,14 @@ export declare const directiveSchema: z.ZodObject<{
                 _type: z.ZodLiteral<"Enum">;
                 name: z.ZodString;
                 $ref: z.ZodString;
-            }, z.core.$strip>]>;
+            }, z.core.$strip>], "_type">;
             defaultValue: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt, z.ZodFloat32, z.ZodBoolean]>>>;
         }, z.core.$strip>, z.ZodObject<{
             _type: z.ZodLiteral<"array">;
             nullable: z.ZodBoolean;
             defaultValue: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodInt>, z.ZodArray<z.ZodFloat32>, z.ZodArray<z.ZodBoolean>]>>>;
             type: z.ZodDiscriminatedUnion<[typeof import("../shared.js").inputLiteralSpecSchema, typeof import("../shared.js").inputArraySpecSchema]>;
-        }, z.core.$strip>]>;
+        }, z.core.$strip>], "_type">;
     }, z.core.$strip>>;
     locations: z.ZodArray<z.ZodEnum<{
         MUTATION: "MUTATION";

package/schema/client/directive.js

@@ -12,5 +12,5 @@ export const directiveSchema = z.object({
         'FRAGMENT_SPREAD',
         'INLINE_FRAGMENT',
         'VARIABLE_DEFINITION',
-    ]))
+    ])),
 });

package/schema/client/fragment.d.ts

@@ -34,7 +34,7 @@ export declare const fieldSelection: z.ZodObject<{
         }, z.core.$strip>, z.ZodObject<{
             _type: z.ZodLiteral<"literal">;
             value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-        }, z.core.$strip>]>;
+        }, z.core.$strip>], "_type">;
     }, z.core.$strip>>;
     selection: z.ZodNullable<FragmentSpecSchemaZodType>;
 }, z.core.$strip>;
@@ -76,7 +76,7 @@ export declare const objectSelection: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodOb
         }, z.core.$strip>, z.ZodObject<{
             _type: z.ZodLiteral<"literal">;
             value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
-        }, z.core.$strip>]>;
+        }, z.core.$strip>], "_type">;
     }, z.core.$strip>>;
     selection: z.ZodNullable<FragmentSpecSchemaZodType>;
 }, z.core.$strip>, z.ZodObject<{
@@ -85,7 +85,7 @@ export declare const objectSelection: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodOb
 }, z.core.$strip>, z.ZodObject<{
     _type: z.ZodLiteral<"SpreadSelection">;
     fragment: z.ZodString;
-}, z.core.$strip>]>>;
+}, z.core.$strip>], "_type">>;
 export declare const objectFragmentSpec: ObjectFragmentSpec;
 export declare const unionFragmentSpec: z.ZodObject<{
     _type: z.ZodLiteral<"UnionFragmentSpec">;
@@ -96,13 +96,13 @@ export declare const fragmentSpecSchema: z.ZodDiscriminatedUnion<[ObjectFragment
     _type: z.ZodLiteral<"UnionFragmentSpec">;
     name: z.ZodString;
     selections: z.ZodArray<UnionSelectionZodType>;
-}, z.core.$strip>]>;
+}, z.core.$strip>], "_type">;
 export declare const fragmentSchema: z.ZodObject<{
     sourceText: z.ZodString;
     spec: z.ZodDiscriminatedUnion<[ObjectFragmentSpec, z.ZodObject<{
         _type: z.ZodLiteral<"UnionFragmentSpec">;
         name: z.ZodString;
         selections: z.ZodArray<UnionSelectionZodType>;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>], "_type">;
 }, z.core.$strip>;
 export {};

package/schema/client/fragment.js

@@ -9,11 +9,11 @@ export const fieldSelection = z.object({
     get selection() {
         // eslint-disable-next-line no-use-before-define
         return z.nullable(fragmentSpecSchema);
-    }
+    },
 });
 export const typenameSelection = z.object({
     _type: z.literal('TypenameField'),
-    alias: z.nullable(z.string())
+    alias: z.nullable(z.string()),
 });
 export const objectConditionalSpreadSelection = z.object({
     _type: z.literal('ObjectConditionalSpreadSelection'),
@@ -21,11 +21,11 @@ export const objectConditionalSpreadSelection = z.object({
     get spec() {
         // eslint-disable-next-line no-use-before-define
         return objectFragmentSpec;
-    }
+    },
 });
 export const spreadSelection = z.object({
     _type: z.literal('SpreadSelection'),
-    fragment: z.string()
+    fragment: z.string(),
 });
 export const unionConditionalSpreadSelection = z.object({
     _type: z.literal('UnionConditionalSpreadSelection'),
@@ -33,7 +33,7 @@ export const unionConditionalSpreadSelection = z.object({
     get selections() {
         // eslint-disable-next-line no-use-before-define
         return z.array(unionSelection);
-    }
+    },
 });
 export const unionSelection = z.lazy(() => z.discriminatedUnion('_type', [
     typenameSelection,
@@ -44,23 +44,23 @@ export const unionSelection = z.lazy(() => z.discriminatedUnion('_type', [
 export const objectSelection = z.lazy(() => z.discriminatedUnion('_type', [
     fieldSelection,
     typenameSelection,
-    spreadSelection
+    spreadSelection,
 ]));
 export const objectFragmentSpec = z.object({
     _type: z.literal('ObjectFragmentSpec'),
     name: z.string(),
-    selections: z.array(objectSelection)
+    selections: z.array(objectSelection),
 });
 export const unionFragmentSpec = z.object({
     _type: z.literal('UnionFragmentSpec'),
     name: z.string(),
-    selections: z.array(unionSelection)
+    selections: z.array(unionSelection),
 });
 export const fragmentSpecSchema = z.discriminatedUnion('_type', [
     objectFragmentSpec,
-    unionFragmentSpec
+    unionFragmentSpec,
 ]);
 export const fragmentSchema = z.object({
     sourceText: z.string(),
-    spec: fragmentSpecSchema
+    spec: fragmentSpecSchema,
 });

package/schema/client/operation.d.ts

@@ -21,14 +21,14 @@ export declare const operationSchema: z.ZodObject<{
                 _type: z.ZodLiteral<"Enum">;
                 name: z.ZodString;
                 $ref: z.ZodString;
-            }, z.core.$strip>]>;
+            }, z.core.$strip>], "_type">;
             defaultValue: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt, z.ZodFloat32, z.ZodBoolean]>>>;
         }, z.core.$strip>, z.ZodObject<{
             _type: z.ZodLiteral<"array">;
             nullable: z.ZodBoolean;
             defaultValue: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodArray<z.ZodInt>, z.ZodArray<z.ZodFloat32>, z.ZodArray<z.ZodBoolean>]>>>;
             type: z.ZodDiscriminatedUnion<[typeof import("../shared.js").inputLiteralSpecSchema, typeof import("../shared.js").inputArraySpecSchema]>;
-        }, z.core.$strip>]>;
+        }, z.core.$strip>], "_type">;
     }, z.core.$strip>>;
     fragmentSpec: z.ZodDiscriminatedUnion<[z.ZodObject<{
         _type: z.ZodLiteral<"ObjectFragmentSpec">;
@@ -38,6 +38,6 @@ export declare const operationSchema: z.ZodObject<{
         _type: z.ZodLiteral<"UnionFragmentSpec">;
         name: z.ZodString;
         selections: z.ZodArray<import("./fragment.js").UnionSelectionZodType>;
-    }, z.core.$strip>]>;
+    }, z.core.$strip>], "_type">;
     sourceText: z.ZodString;
 }, z.core.$strip>;