@constructive-io/graphql-codegen 3.2.1 → 3.3.0

package/core/codegen/gql-ast.js

@@ -1,353 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildListQueryAST = buildListQueryAST;
-exports.buildSingleQueryAST = buildSingleQueryAST;
-exports.buildCreateMutationAST = buildCreateMutationAST;
-exports.buildUpdateMutationAST = buildUpdateMutationAST;
-exports.buildDeleteMutationAST = buildDeleteMutationAST;
-exports.printGraphQL = printGraphQL;
-/**
- * GraphQL AST builders using gql-ast
- *
- * Provides utilities for generating GraphQL queries and mutations via AST
- * instead of string concatenation.
- */
-const t = __importStar(require("gql-ast"));
-const graphql_1 = require("graphql");
-const utils_1 = require("./utils");
-// ============================================================================
-// Field selection builders
-// ============================================================================
-/**
- * Create field selections from CleanField array
- */
-function createFieldSelections(fields) {
-    return fields.map((field) => t.field({ name: field.name }));
-}
-/**
- * Create pageInfo selection
- */
-function createPageInfoSelection() {
-    return t.field({
-        name: 'pageInfo',
-        selectionSet: t.selectionSet({
-            selections: [
-                t.field({ name: 'hasNextPage' }),
-                t.field({ name: 'hasPreviousPage' }),
-                t.field({ name: 'startCursor' }),
-                t.field({ name: 'endCursor' }),
-            ],
-        }),
-    });
-}
-/**
- * Build a list query AST for a table
- */
-function buildListQueryAST(config) {
-    const { table } = config;
-    const queryName = (0, utils_1.getAllRowsQueryName)(table);
-    const filterType = (0, utils_1.getFilterTypeName)(table);
-    const conditionType = (0, utils_1.getConditionTypeName)(table);
-    const orderByType = (0, utils_1.getOrderByTypeName)(table);
-    const scalarFields = (0, utils_1.getScalarFields)(table);
-    // Variable definitions - all pagination arguments from PostGraphile
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'first' }),
-            type: t.namedType({ type: 'Int' }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'last' }),
-            type: t.namedType({ type: 'Int' }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'offset' }),
-            type: t.namedType({ type: 'Int' }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'before' }),
-            type: t.namedType({ type: 'Cursor' }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'after' }),
-            type: t.namedType({ type: 'Cursor' }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'filter' }),
-            type: t.namedType({ type: filterType }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'condition' }),
-            type: t.namedType({ type: conditionType }),
-        }),
-        t.variableDefinition({
-            variable: t.variable({ name: 'orderBy' }),
-            type: t.listType({
-                type: t.nonNullType({ type: t.namedType({ type: orderByType }) }),
-            }),
-        }),
-    ];
-    // Query arguments
-    const args = [
-        t.argument({ name: 'first', value: t.variable({ name: 'first' }) }),
-        t.argument({ name: 'last', value: t.variable({ name: 'last' }) }),
-        t.argument({ name: 'offset', value: t.variable({ name: 'offset' }) }),
-        t.argument({ name: 'before', value: t.variable({ name: 'before' }) }),
-        t.argument({ name: 'after', value: t.variable({ name: 'after' }) }),
-        t.argument({ name: 'filter', value: t.variable({ name: 'filter' }) }),
-        t.argument({ name: 'condition', value: t.variable({ name: 'condition' }) }),
-        t.argument({ name: 'orderBy', value: t.variable({ name: 'orderBy' }) }),
-    ];
-    // Field selections
-    const fieldSelections = createFieldSelections(scalarFields);
-    // Connection fields
-    const connectionFields = [
-        t.field({ name: 'totalCount' }),
-        t.field({
-            name: 'nodes',
-            selectionSet: t.selectionSet({ selections: fieldSelections }),
-        }),
-        createPageInfoSelection(),
-    ];
-    return t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: `${(0, utils_1.ucFirst)(queryName)}Query`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: queryName,
-                            args,
-                            selectionSet: t.selectionSet({ selections: connectionFields }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-}
-/**
- * Build a single item query AST for a table
- */
-function buildSingleQueryAST(config) {
-    const { table } = config;
-    const queryName = (0, utils_1.getSingleRowQueryName)(table);
-    const scalarFields = (0, utils_1.getScalarFields)(table);
-    // Get primary key info dynamically from table constraints
-    const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
-    // For simplicity, use first PK field (most common case)
-    const pkField = pkFields[0];
-    // Variable definitions - use dynamic PK field name and type
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: pkField.name }),
-            type: t.nonNullType({ type: t.namedType({ type: pkField.gqlType }) }),
-        }),
-    ];
-    // Query arguments - use dynamic PK field name
-    const args = [
-        t.argument({ name: pkField.name, value: t.variable({ name: pkField.name }) }),
-    ];
-    // Field selections
-    const fieldSelections = createFieldSelections(scalarFields);
-    return t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: `${(0, utils_1.ucFirst)(queryName)}Query`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: queryName,
-                            args,
-                            selectionSet: t.selectionSet({ selections: fieldSelections }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-}
-/**
- * Build a create mutation AST for a table
- */
-function buildCreateMutationAST(config) {
-    const { table } = config;
-    const { typeName, singularName } = (0, utils_1.getTableNames)(table);
-    const mutationName = (0, utils_1.getCreateMutationName)(table);
-    const inputTypeName = `Create${typeName}Input`;
-    const scalarFields = (0, utils_1.getScalarFields)(table);
-    // Variable definitions
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }),
-        }),
-    ];
-    // Mutation arguments
-    const args = [
-        t.argument({ name: 'input', value: t.variable({ name: 'input' }) }),
-    ];
-    // Field selections
-    const fieldSelections = createFieldSelections(scalarFields);
-    return t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'mutation',
-                name: `${(0, utils_1.ucFirst)(mutationName)}Mutation`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: mutationName,
-                            args,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({
-                                        name: singularName,
-                                        selectionSet: t.selectionSet({ selections: fieldSelections }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-}
-/**
- * Build an update mutation AST for a table
- */
-function buildUpdateMutationAST(config) {
-    const { table } = config;
-    const { typeName, singularName } = (0, utils_1.getTableNames)(table);
-    const mutationName = (0, utils_1.getUpdateMutationName)(table);
-    const inputTypeName = `Update${typeName}Input`;
-    const scalarFields = (0, utils_1.getScalarFields)(table);
-    // Variable definitions
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }),
-        }),
-    ];
-    // Mutation arguments
-    const args = [
-        t.argument({ name: 'input', value: t.variable({ name: 'input' }) }),
-    ];
-    // Field selections
-    const fieldSelections = createFieldSelections(scalarFields);
-    return t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'mutation',
-                name: `${(0, utils_1.ucFirst)(mutationName)}Mutation`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: mutationName,
-                            args,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({
-                                        name: singularName,
-                                        selectionSet: t.selectionSet({ selections: fieldSelections }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-}
-/**
- * Build a delete mutation AST for a table
- */
-function buildDeleteMutationAST(config) {
-    const { table } = config;
-    const { typeName } = (0, utils_1.getTableNames)(table);
-    const mutationName = (0, utils_1.getDeleteMutationName)(table);
-    const inputTypeName = `Delete${typeName}Input`;
-    // Variable definitions
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }),
-        }),
-    ];
-    // Mutation arguments
-    const args = [
-        t.argument({ name: 'input', value: t.variable({ name: 'input' }) }),
-    ];
-    return t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'mutation',
-                name: `${(0, utils_1.ucFirst)(mutationName)}Mutation`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: mutationName,
-                            args,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({ name: 'clientMutationId' }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-}
-// ============================================================================
-// Print utilities
-// ============================================================================
-/**
- * Print AST to GraphQL string
- */
-function printGraphQL(ast) {
-    return (0, graphql_1.print)(ast);
-}

package/core/codegen/schema-gql-ast.d.ts

@@ -1,51 +0,0 @@
-import type { DocumentNode, FieldNode, VariableDefinitionNode } from 'graphql';
-import type { CleanOperation, CleanArgument, CleanTypeRef, TypeRegistry } from '../../types/schema';
-export interface FieldSelectionConfig {
-    /** Max depth for nested object selections */
-    maxDepth: number;
-    /** Skip the 'query' field in payloads */
-    skipQueryField: boolean;
-    /** Type registry for resolving nested types */
-    typeRegistry?: TypeRegistry;
-}
-/**
- * Build variable definitions from operation arguments
- */
-export declare function buildVariableDefinitions(args: CleanArgument[]): VariableDefinitionNode[];
-/**
- * Build field selections for an object type
- * Recursively handles nested objects up to maxDepth
- */
-export declare function buildFieldSelections(typeRef: CleanTypeRef, config: FieldSelectionConfig, currentDepth?: number): FieldNode[];
-export interface CustomQueryConfig {
-    operation: CleanOperation;
-    typeRegistry?: TypeRegistry;
-    maxDepth?: number;
-    skipQueryField?: boolean;
-}
-/**
- * Build a custom query AST from a CleanOperation
- */
-export declare function buildCustomQueryAST(config: CustomQueryConfig): DocumentNode;
-export interface CustomMutationConfig {
-    operation: CleanOperation;
-    typeRegistry?: TypeRegistry;
-    maxDepth?: number;
-    skipQueryField?: boolean;
-}
-/**
- * Build a custom mutation AST from a CleanOperation
- */
-export declare function buildCustomMutationAST(config: CustomMutationConfig): DocumentNode;
-/**
- * Print a document AST to GraphQL string
- */
-export declare function printGraphQL(ast: DocumentNode): string;
-/**
- * Build and print a custom query in one call
- */
-export declare function buildCustomQueryString(config: CustomQueryConfig): string;
-/**
- * Build and print a custom mutation in one call
- */
-export declare function buildCustomMutationString(config: CustomMutationConfig): string;