@vladimirdev635/gql-codegen 0.0.109 → 0.0.111

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

@@ -1,195 +0,0 @@
-/* eslint-disable max-lines */
-import ts from 'typescript';
-import { generateSchemaName, generateZodInferTypeAlias, } from '../server/shared.js';
-import { generateZodObjectFieldSpec } from '../server/objects.js';
-import assert from 'assert';
-import { invokeMethod } from '../../../shared.js';
-export function extractFragmentNamesInSpec(schema, fragmentSpec) {
-    if (fragmentSpec._type === 'UnionFragmentSpec') {
-        return fragmentSpec.selections
-            .map((s) => {
-            if (s._type === 'SpreadSelection') {
-                const fragment = schema.client.fragments[s.fragment];
-                return [
-                    s.fragment,
-                    ...extractFragmentNamesInSpec(schema, fragment.spec),
-                ];
-            }
-            if (s._type === 'ObjectConditionalSpreadSelection') {
-                return extractFragmentNamesInSpec(schema, s.spec);
-            }
-            return [];
-        })
-            .flat();
-    }
-    return fragmentSpec.selections
-        .map((s) => {
-        if (s._type === 'SpreadSelection') {
-            const fragment = schema.client.fragments[s.fragment];
-            assert(fragment.spec !== undefined);
-            return [
-                s.fragment,
-                ...extractFragmentNamesInSpec(schema, fragment.spec),
-            ];
-        }
-        if (s._type === 'FieldSelection' && s.selection != null) {
-            assert(s.selection !== undefined);
-            return extractFragmentNamesInSpec(schema, s.selection);
-        }
-        return [];
-    })
-        .flat();
-}
-export function extractFragmentSourceTextsInSpec(schema, fragmentSpec) {
-    return Array.from(new Set(extractFragmentNamesInSpec(schema, fragmentSpec))).map((f) => schema.client.fragments[f].sourceText);
-}
-function generateFragmentDocumentNode(schema, name, fragment) {
-    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(name + 'FragmentDocument'), undefined, undefined, ts.factory.createStringLiteral([
-            fragment.sourceText,
-            ...extractFragmentSourceTextsInSpec(schema, fragment.spec),
-        ].join(' '))),
-    ], ts.NodeFlags.Const));
-}
-function generateZodObjectSelection(scalarsMapping, schema, objectType, selection, typenameConfig) {
-    switch (selection._type) {
-        case 'TypenameField': {
-            if ('ignore' in typenameConfig)
-                return null;
-            let expression = invokeMethod(ts.factory.createIdentifier('z'), 'literal', [ts.factory.createStringLiteral(objectType.name)]);
-            if (selection.alias === null && typenameConfig.optional) {
-                expression = invokeMethod(invokeMethod(expression, 'nullable', []), 'optional', []);
-            }
-            return ts.factory.createPropertyAssignment(selection.alias || '__typename', expression);
-        }
-        case 'FieldSelection': {
-            const fieldSpec = objectType.fields[selection.name];
-            let expression;
-            if (selection.selection == null) {
-                expression = generateZodObjectFieldSpec(scalarsMapping, fieldSpec);
-            }
-            else {
-                const optional = fieldSpec.spec._type !== 'callable' ||
-                    !selection.selection.selections.every((s) => s._type === 'TypenameField') ||
-                    !fieldSpec.nullable;
-                // eslint-disable-next-line no-use-before-define
-                expression = generateZodFragmentSpecCallExpression(scalarsMapping, schema, selection.selection, { ensurePresent: true, optional });
-                if (fieldSpec.spec._type === 'array' ||
-                    (fieldSpec.spec._type === 'callable' &&
-                        fieldSpec.spec.returnType._type === 'array')) {
-                    expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'array'), undefined, [expression]);
-                }
-            }
-            if (fieldSpec.nullable) {
-                expression = invokeMethod(invokeMethod(expression, 'nullable', []), 'optional', []);
-            }
-            return ts.factory.createPropertyAssignment(selection.alias, expression);
-        }
-        case 'SpreadSelection': {
-            return ts.factory.createSpreadAssignment(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(generateSchemaName(selection.fragment + 'Fragment')), 'shape'));
-        }
-    }
-}
-function resolveSelections(specSelections, typenameConfig) {
-    const ignoreTypename = 'ignore' in typenameConfig;
-    const selections = specSelections
-        .filter((s) => s._type !== 'TypenameField' || !ignoreTypename)
-        .toSorted((s1, s2) => s1._type.localeCompare(s2._type));
-    if (ignoreTypename)
-        return selections;
-    const hasTypename = specSelections.some((s) => s._type === 'TypenameField');
-    const hasSpreadSelection = specSelections.some((s) => s._type === 'SpreadSelection');
-    if (!hasTypename) {
-        if (hasSpreadSelection) {
-            selections.push({ _type: 'TypenameField', alias: null });
-        }
-        else {
-            selections.unshift({ _type: 'TypenameField', alias: null });
-        }
-    }
-    return selections;
-}
-function generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, object, specSelections, insideLazy, typenameConfig) {
-    const selections = resolveSelections(specSelections, typenameConfig);
-    const expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'object'), undefined, [
-        ts.factory.createObjectLiteralExpression(selections
-            .map((s) => generateZodObjectSelection(scalarsMapping, schema, object, s, typenameConfig))
-            .filter((s) => s !== null), true),
-    ]);
-    if (insideLazy)
-        return expression;
-    const hasSpreadSelection = selections.some((s) => s._type === 'SpreadSelection');
-    if (!hasSpreadSelection)
-        return expression;
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'lazy'), undefined, [
-        ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expression),
-    ]);
-}
-function resolveUnionSelections(schema, specSelections) {
-    const typenameSelections = [];
-    const objectSelections = specSelections
-        .map((s) => {
-        assert(s._type !== 'UnionConditionalSpreadSelection');
-        if (s._type === 'TypenameField') {
-            typenameSelections.push(s);
-            return [];
-        }
-        if (s._type === 'ObjectConditionalSpreadSelection')
-            return [s];
-        const fragmentSpec = schema.client.fragments[s.fragment].spec;
-        assert(fragmentSpec._type === 'UnionFragmentSpec');
-        const [selections, tSelections] = resolveUnionSelections(schema, fragmentSpec.selections);
-        typenameSelections.push(...tSelections);
-        return selections;
-    })
-        .flat();
-    return [objectSelections, typenameSelections];
-}
-function generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec) {
-    const [objectSelections, typenameSelections] = resolveUnionSelections(schema, spec.selections);
-    for (const item of Object.keys(schema.server.unions[spec.name].items)) {
-        if (!objectSelections.some((s) => s.object === item)) {
-            objectSelections.push({
-                _type: 'ObjectConditionalSpreadSelection',
-                object: item,
-                spec: {
-                    _type: 'ObjectFragmentSpec',
-                    name: item,
-                    selections: [],
-                },
-            });
-        }
-    }
-    const expression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'union'), undefined, [
-        ts.factory.createArrayLiteralExpression(objectSelections.map((s) => generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[s.object], [...s.spec.selections, ...typenameSelections], true, { ensurePresent: true, optional: false })), true),
-    ]);
-    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'lazy'), undefined, [
-        ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), expression),
-    ]);
-}
-export function generateZodFragmentSpecCallExpression(scalarsMapping, schema, spec, typenameConfig) {
-    if (spec._type === 'ObjectFragmentSpec') {
-        return generateZodObjectFragmentSpecCallExpression(scalarsMapping, schema, schema.server.objects[spec.name], spec.selections, false, typenameConfig || { ensurePresent: true, optional: true });
-    }
-    return generateZodUnionFragmentSpecCallExpression(scalarsMapping, schema, spec);
-}
-function generateZodFragmentSchema(scalarsMapping, schema, fragmentName, fragment) {
-    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(fragmentName + 'Fragment')), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, fragment.spec)),
-    ], ts.NodeFlags.Const));
-}
-function generateFragmentSpecDeclarations(scalarsMapping, schema, fragmentName, fragment) {
-    const fName = fragmentName + 'Fragment';
-    return [
-        generateFragmentDocumentNode(schema, fragmentName, fragment),
-        generateZodFragmentSchema(scalarsMapping, schema, fragmentName, fragment),
-        generateZodInferTypeAlias('output', fName, generateSchemaName(fName)),
-    ];
-}
-export function generateFragmentTypes(scalarsMapping, schema) {
-    return Object.entries(schema.client.fragments)
-        .map(([name, fragment]) => {
-        return generateFragmentSpecDeclarations(scalarsMapping, schema, name, fragment);
-    })
-        .flat();
-}

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

@@ -1,7 +0,0 @@
-import ts from 'typescript';
-import { RootSchema } from '../../../../../schema/root.js';
-import { operationSchema } from '../../../../../schema/client/operation.js';
-import { z } from 'zod/v4';
-import { ScalarsMapping } from '../server/scalars/mapping.js';
-export declare function opTypeToName(type: z.infer<typeof operationSchema>['type']): string;
-export declare function generateOperationsNodes(scalarsMapping: ScalarsMapping, schema: RootSchema): ts.Node[];

package/actors/ts/graphql/generators/client/operations.js

@@ -1,68 +0,0 @@
-/* eslint-disable max-lines */
-import ts from 'typescript';
-import { extractFragmentSourceTextsInSpec, generateZodFragmentSpecCallExpression, } from './fragments.js';
-import { generateSchemaName, generateZodInferTypeAlias, } from '../server/shared.js';
-import { generateInputTypeDefinitionFields } from '../server/inputs.js';
-export function opTypeToName(type) {
-    switch (type) {
-        case 'QUERY':
-            return 'Query';
-        case 'MUTATION':
-            return 'Mutation';
-        case 'SUBSCRIPTION':
-            return 'Subscription';
-    }
-}
-function parametersToFields(parameters) {
-    return Object.fromEntries(Object.keys(parameters).map((name) => [
-        name.slice(1),
-        parameters[name],
-    ]));
-}
-function generateOperationNode(schema, operation) {
-    return ts.factory.createVariableStatement(ts.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(operation.name + 'Operation'), undefined, undefined, ts.factory.createSatisfiesExpression(ts.factory.createAsExpression(ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment('name', ts.factory.createStringLiteral(operation.name)),
-            ts.factory.createPropertyAssignment('type', ts.factory.createStringLiteral(operation.type)),
-            ts.factory.createPropertyAssignment('document', ts.factory.createStringLiteral([
-                operation.sourceText,
-                ...extractFragmentSourceTextsInSpec(schema, operation.fragmentSpec),
-            ].join(' '))),
-            ts.factory.createPropertyAssignment('variablesSchema', ts.factory.createIdentifier(generateSchemaName(operation.name + 'Variables'))),
-            ts.factory.createPropertyAssignment('resultSchema', ts.factory.createIdentifier(generateSchemaName(operation.name + 'Result'))),
-        ], true), ts.factory.createTypeReferenceNode('const')), ts.factory.createTypeReferenceNode('Operation', [
-            ts.factory.createTypeReferenceNode(operation.name + 'Variables'),
-            ts.factory.createTypeReferenceNode(operation.name + 'Result'),
-        ]))),
-    ], ts.NodeFlags.Const));
-}
-function generateOperationZodInputSchema(scalarsMapping, operation) {
-    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(operation.name + 'Variables')), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), 'object'), undefined, [
-            ts.factory.createObjectLiteralExpression(generateInputTypeDefinitionFields(scalarsMapping, parametersToFields(operation.parameters)), true),
-        ])),
-    ], ts.NodeFlags.Const));
-}
-function genearteOperationZodOutputSchema(scalarsMapping, schema, operation) {
-    return ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(generateSchemaName(operation.name + 'Result')), undefined, undefined, generateZodFragmentSpecCallExpression(scalarsMapping, schema, operation.fragmentSpec)),
-    ], ts.NodeFlags.Const));
-}
-function generateOperationNodes(scalarsMapping, schema, operation) {
-    return [
-        generateOperationZodInputSchema(scalarsMapping, operation),
-        generateZodInferTypeAlias('input', operation.name + 'Variables', generateSchemaName(operation.name + 'Variables')),
-        ts.factory.createIdentifier('\n'),
-        genearteOperationZodOutputSchema(scalarsMapping, schema, operation),
-        generateZodInferTypeAlias('output', operation.name + 'Result', generateSchemaName(operation.name + 'Result')),
-        generateOperationNode(schema, operation),
-        ts.factory.createIdentifier('\n'),
-    ];
-}
-export function generateOperationsNodes(scalarsMapping, schema) {
-    return Object.values(schema.client.operations)
-        .map((operation) => {
-        return generateOperationNodes(scalarsMapping, schema, operation);
-    })
-        .flat();
-}