@constructive-io/graphql-codegen 2.26.0 → 2.27.1

package/cli/codegen/orm/client.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ORM Client - Type stub for compile-time type checking
+ *
+ * This is a stub file that provides type definitions for query-builder.ts
+ * during compilation. The actual client.ts is generated at codegen time
+ * from the generateOrmClientFile() function in client-generator.ts.
+ *
+ * @internal This file is NOT part of the generated output
+ */
+export interface OrmClientConfig {
+    endpoint: string;
+    headers?: Record<string, string>;
+}
+export interface GraphQLError {
+    message: string;
+    locations?: {
+        line: number;
+        column: number;
+    }[];
+    path?: (string | number)[];
+    extensions?: Record<string, unknown>;
+}
+export declare class GraphQLRequestError extends Error {
+    readonly errors: GraphQLError[];
+    readonly data: unknown;
+    constructor(errors: GraphQLError[], data?: unknown);
+}
+export type QueryResult<T> = {
+    ok: true;
+    data: T;
+    errors: undefined;
+} | {
+    ok: false;
+    data: null;
+    errors: GraphQLError[];
+};
+export declare class OrmClient {
+    private endpoint;
+    private headers;
+    constructor(config: OrmClientConfig);
+    execute<T>(document: string, variables?: Record<string, unknown>): Promise<QueryResult<T>>;
+    setHeaders(headers: Record<string, string>): void;
+    getEndpoint(): string;
+}

package/cli/codegen/orm/client.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * ORM Client - Type stub for compile-time type checking
+ *
+ * This is a stub file that provides type definitions for query-builder.ts
+ * during compilation. The actual client.ts is generated at codegen time
+ * from the generateOrmClientFile() function in client-generator.ts.
+ *
+ * @internal This file is NOT part of the generated output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrmClient = exports.GraphQLRequestError = void 0;
+class GraphQLRequestError extends Error {
+    errors;
+    data;
+    constructor(errors, data = null) {
+        const messages = errors.map((e) => e.message).join('; ');
+        super(`GraphQL Error: ${messages}`);
+        this.errors = errors;
+        this.data = data;
+        this.name = 'GraphQLRequestError';
+    }
+}
+exports.GraphQLRequestError = GraphQLRequestError;
+class OrmClient {
+    endpoint;
+    headers;
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.headers = config.headers ?? {};
+    }
+    async execute(document, variables) {
+        const response = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...this.headers,
+            },
+            body: JSON.stringify({
+                query: document,
+                variables: variables ?? {},
+            }),
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                data: null,
+                errors: [{ message: `HTTP ${response.status}: ${response.statusText}` }],
+            };
+        }
+        const json = (await response.json());
+        if (json.errors && json.errors.length > 0) {
+            return {
+                ok: false,
+                data: null,
+                errors: json.errors,
+            };
+        }
+        return {
+            ok: true,
+            data: json.data,
+            errors: undefined,
+        };
+    }
+    setHeaders(headers) {
+        this.headers = { ...this.headers, ...headers };
+    }
+    getEndpoint() {
+        return this.endpoint;
+    }
+}
+exports.OrmClient = OrmClient;

package/cli/codegen/orm/query-builder.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Query Builder - Builds and executes GraphQL operations
+ *
+ * This is the RUNTIME code that gets copied to generated output.
+ * It uses gql-ast to build GraphQL documents programmatically.
+ *
+ * NOTE: This file is read at codegen time and written to output.
+ * Any changes here will affect all generated ORM clients.
+ */
+import type { FieldNode } from 'graphql';
+import { OrmClient, QueryResult } from './client';
+export interface QueryBuilderConfig {
+    client: OrmClient;
+    operation: 'query' | 'mutation';
+    operationName: string;
+    fieldName: string;
+    document: string;
+    variables?: Record<string, unknown>;
+}
+export declare class QueryBuilder<TResult> {
+    private config;
+    constructor(config: QueryBuilderConfig);
+    /**
+     * Execute the query and return a discriminated union result
+     * Use result.ok to check success, or .unwrap() to throw on error
+     */
+    execute(): Promise<QueryResult<TResult>>;
+    /**
+     * Execute and unwrap the result, throwing GraphQLRequestError on failure
+     * @throws {GraphQLRequestError} If the query returns errors
+     */
+    unwrap(): Promise<TResult>;
+    /**
+     * Execute and unwrap, returning defaultValue on error instead of throwing
+     */
+    unwrapOr<D>(defaultValue: D): Promise<TResult | D>;
+    /**
+     * Execute and unwrap, calling onError callback on failure
+     */
+    unwrapOrElse<D>(onError: (errors: import('./client').GraphQLError[]) => D): Promise<TResult | D>;
+    toGraphQL(): string;
+    getVariables(): Record<string, unknown> | undefined;
+}
+export declare function buildSelections(select: Record<string, unknown> | undefined): FieldNode[];
+export declare function buildFindManyDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+    orderBy?: string[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}, filterTypeName: string, orderByTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindFirstDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+}, filterTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCreateDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, data: TData, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateDocument<TSelect, TWhere extends {
+    id: string;
+}, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteDocument<TWhere extends {
+    id: string;
+}>(operationName: string, mutationField: string, entityField: string, where: TWhere, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCustomDocument<TSelect, TArgs>(operationType: 'query' | 'mutation', operationName: string, fieldName: string, select: TSelect, args: TArgs, variableDefinitions: Array<{
+    name: string;
+    type: string;
+}>): {
+    document: string;
+    variables: Record<string, unknown>;
+};

package/cli/codegen/orm/query-builder.js

@@ -0,0 +1,485 @@
+"use strict";
+/**
+ * Query Builder - Builds and executes GraphQL operations
+ *
+ * This is the RUNTIME code that gets copied to generated output.
+ * It uses gql-ast to build GraphQL documents programmatically.
+ *
+ * NOTE: This file is read at codegen time and written to output.
+ * Any changes here will affect all generated ORM clients.
+ */
+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.QueryBuilder = void 0;
+exports.buildSelections = buildSelections;
+exports.buildFindManyDocument = buildFindManyDocument;
+exports.buildFindFirstDocument = buildFindFirstDocument;
+exports.buildCreateDocument = buildCreateDocument;
+exports.buildUpdateDocument = buildUpdateDocument;
+exports.buildDeleteDocument = buildDeleteDocument;
+exports.buildCustomDocument = buildCustomDocument;
+const t = __importStar(require("gql-ast"));
+const graphql_1 = require("graphql");
+const client_1 = require("./client");
+class QueryBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Execute the query and return a discriminated union result
+     * Use result.ok to check success, or .unwrap() to throw on error
+     */
+    async execute() {
+        return this.config.client.execute(this.config.document, this.config.variables);
+    }
+    /**
+     * Execute and unwrap the result, throwing GraphQLRequestError on failure
+     * @throws {GraphQLRequestError} If the query returns errors
+     */
+    async unwrap() {
+        const result = await this.execute();
+        if (!result.ok) {
+            throw new client_1.GraphQLRequestError(result.errors, result.data);
+        }
+        return result.data;
+    }
+    /**
+     * Execute and unwrap, returning defaultValue on error instead of throwing
+     */
+    async unwrapOr(defaultValue) {
+        const result = await this.execute();
+        if (!result.ok) {
+            return defaultValue;
+        }
+        return result.data;
+    }
+    /**
+     * Execute and unwrap, calling onError callback on failure
+     */
+    async unwrapOrElse(onError) {
+        const result = await this.execute();
+        if (!result.ok) {
+            return onError(result.errors);
+        }
+        return result.data;
+    }
+    toGraphQL() {
+        return this.config.document;
+    }
+    getVariables() {
+        return this.config.variables;
+    }
+}
+exports.QueryBuilder = QueryBuilder;
+// ============================================================================
+// Selection Builders
+// ============================================================================
+function buildSelections(select) {
+    if (!select) {
+        return [];
+    }
+    const fields = [];
+    for (const [key, value] of Object.entries(select)) {
+        if (value === false || value === undefined) {
+            continue;
+        }
+        if (value === true) {
+            fields.push(t.field({ name: key }));
+            continue;
+        }
+        if (typeof value === 'object' && value !== null) {
+            const nested = value;
+            if (nested.select) {
+                const nestedSelections = buildSelections(nested.select);
+                const isConnection = nested.connection === true ||
+                    nested.first !== undefined ||
+                    nested.filter !== undefined;
+                const args = buildArgs([
+                    buildOptionalArg('first', nested.first),
+                    nested.filter
+                        ? t.argument({ name: 'filter', value: buildValueAst(nested.filter) })
+                        : null,
+                    buildEnumListArg('orderBy', nested.orderBy),
+                ]);
+                if (isConnection) {
+                    fields.push(t.field({
+                        name: key,
+                        args,
+                        selectionSet: t.selectionSet({
+                            selections: buildConnectionSelections(nestedSelections),
+                        }),
+                    }));
+                }
+                else {
+                    fields.push(t.field({
+                        name: key,
+                        args,
+                        selectionSet: t.selectionSet({ selections: nestedSelections }),
+                    }));
+                }
+            }
+        }
+    }
+    return fields;
+}
+// ============================================================================
+// Document Builders
+// ============================================================================
+function buildFindManyDocument(operationName, queryField, select, args, filterTypeName, orderByTypeName) {
+    const selections = select
+        ? buildSelections(select)
+        : [t.field({ name: 'id' })];
+    const variableDefinitions = [];
+    const queryArgs = [];
+    const variables = {};
+    addVariable({ varName: 'where', argName: 'filter', typeName: filterTypeName, value: args.where }, variableDefinitions, queryArgs, variables);
+    addVariable({
+        varName: 'orderBy',
+        typeName: '[' + orderByTypeName + '!]',
+        value: args.orderBy?.length ? args.orderBy : undefined,
+    }, variableDefinitions, queryArgs, variables);
+    addVariable({ varName: 'first', typeName: 'Int', value: args.first }, variableDefinitions, queryArgs, variables);
+    addVariable({ varName: 'last', typeName: 'Int', value: args.last }, variableDefinitions, queryArgs, variables);
+    addVariable({ varName: 'after', typeName: 'Cursor', value: args.after }, variableDefinitions, queryArgs, variables);
+    addVariable({ varName: 'before', typeName: 'Cursor', value: args.before }, variableDefinitions, queryArgs, variables);
+    addVariable({ varName: 'offset', typeName: 'Int', value: args.offset }, variableDefinitions, queryArgs, variables);
+    const document = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'query',
+                name: operationName + 'Query',
+                variableDefinitions: variableDefinitions.length ? variableDefinitions : undefined,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: queryField,
+                            args: queryArgs.length ? queryArgs : undefined,
+                            selectionSet: t.selectionSet({
+                                selections: buildConnectionSelections(selections),
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return { document: (0, graphql_1.print)(document), variables };
+}
+function buildFindFirstDocument(operationName, queryField, select, args, filterTypeName) {
+    const selections = select
+        ? buildSelections(select)
+        : [t.field({ name: 'id' })];
+    const variableDefinitions = [];
+    const queryArgs = [];
+    const variables = {};
+    // Always add first: 1 for findFirst
+    addVariable({ varName: 'first', typeName: 'Int', value: 1 }, variableDefinitions, queryArgs, variables);
+    addVariable({ varName: 'where', argName: 'filter', typeName: filterTypeName, value: args.where }, variableDefinitions, queryArgs, variables);
+    const document = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'query',
+                name: operationName + 'Query',
+                variableDefinitions,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: queryField,
+                            args: queryArgs,
+                            selectionSet: t.selectionSet({
+                                selections: [
+                                    t.field({
+                                        name: 'nodes',
+                                        selectionSet: t.selectionSet({ selections }),
+                                    }),
+                                ],
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return { document: (0, graphql_1.print)(document), variables };
+}
+function buildCreateDocument(operationName, mutationField, entityField, select, data, inputTypeName) {
+    const selections = select
+        ? buildSelections(select)
+        : [t.field({ name: 'id' })];
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({
+                    name: entityField,
+                    selectionSet: t.selectionSet({ selections }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                [entityField]: data,
+            },
+        },
+    };
+}
+function buildUpdateDocument(operationName, mutationField, entityField, select, where, data, inputTypeName) {
+    const selections = select
+        ? buildSelections(select)
+        : [t.field({ name: 'id' })];
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({
+                    name: entityField,
+                    selectionSet: t.selectionSet({ selections }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                id: where.id,
+                patch: data,
+            },
+        },
+    };
+}
+function buildDeleteDocument(operationName, mutationField, entityField, where, inputTypeName) {
+    return {
+        document: buildInputMutationDocument({
+            operationName,
+            mutationField,
+            inputTypeName,
+            resultSelections: [
+                t.field({
+                    name: entityField,
+                    selectionSet: t.selectionSet({
+                        selections: [t.field({ name: 'id' })],
+                    }),
+                }),
+            ],
+        }),
+        variables: {
+            input: {
+                id: where.id,
+            },
+        },
+    };
+}
+function buildCustomDocument(operationType, operationName, fieldName, select, args, variableDefinitions) {
+    let actualSelect = select;
+    let isConnection = false;
+    if (select && typeof select === 'object' && 'select' in select) {
+        const wrapper = select;
+        if (wrapper.select) {
+            actualSelect = wrapper.select;
+            isConnection = wrapper.connection === true;
+        }
+    }
+    const selections = actualSelect
+        ? buildSelections(actualSelect)
+        : [];
+    const variableDefs = variableDefinitions.map((definition) => t.variableDefinition({
+        variable: t.variable({ name: definition.name }),
+        type: (0, graphql_1.parseType)(definition.type),
+    }));
+    const fieldArgs = variableDefinitions.map((definition) => t.argument({
+        name: definition.name,
+        value: t.variable({ name: definition.name }),
+    }));
+    const fieldSelections = isConnection
+        ? buildConnectionSelections(selections)
+        : selections;
+    const document = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: operationType,
+                name: operationName,
+                variableDefinitions: variableDefs.length ? variableDefs : undefined,
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: fieldName,
+                            args: fieldArgs.length ? fieldArgs : undefined,
+                            selectionSet: fieldSelections.length
+                                ? t.selectionSet({ selections: fieldSelections })
+                                : undefined,
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return {
+        document: (0, graphql_1.print)(document),
+        variables: (args ?? {}),
+    };
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function buildArgs(args) {
+    return args.filter((arg) => arg !== null);
+}
+function buildOptionalArg(name, value) {
+    if (value === undefined) {
+        return null;
+    }
+    const valueNode = typeof value === 'number'
+        ? t.intValue({ value: value.toString() })
+        : t.stringValue({ value });
+    return t.argument({ name, value: valueNode });
+}
+function buildEnumListArg(name, values) {
+    if (!values || values.length === 0) {
+        return null;
+    }
+    return t.argument({
+        name,
+        value: t.listValue({
+            values: values.map((value) => buildEnumValue(value)),
+        }),
+    });
+}
+function buildEnumValue(value) {
+    return {
+        kind: 'EnumValue',
+        value,
+    };
+}
+function buildPageInfoSelections() {
+    return [
+        t.field({ name: 'hasNextPage' }),
+        t.field({ name: 'hasPreviousPage' }),
+        t.field({ name: 'startCursor' }),
+        t.field({ name: 'endCursor' }),
+    ];
+}
+function buildConnectionSelections(nodeSelections) {
+    return [
+        t.field({
+            name: 'nodes',
+            selectionSet: t.selectionSet({ selections: nodeSelections }),
+        }),
+        t.field({ name: 'totalCount' }),
+        t.field({
+            name: 'pageInfo',
+            selectionSet: t.selectionSet({ selections: buildPageInfoSelections() }),
+        }),
+    ];
+}
+function buildInputMutationDocument(config) {
+    const document = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'mutation',
+                name: config.operationName + 'Mutation',
+                variableDefinitions: [
+                    t.variableDefinition({
+                        variable: t.variable({ name: 'input' }),
+                        type: (0, graphql_1.parseType)(config.inputTypeName + '!'),
+                    }),
+                ],
+                selectionSet: t.selectionSet({
+                    selections: [
+                        t.field({
+                            name: config.mutationField,
+                            args: [
+                                t.argument({
+                                    name: 'input',
+                                    value: t.variable({ name: 'input' }),
+                                }),
+                            ],
+                            selectionSet: t.selectionSet({
+                                selections: config.resultSelections,
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return (0, graphql_1.print)(document);
+}
+function addVariable(spec, definitions, args, variables) {
+    if (spec.value === undefined)
+        return;
+    definitions.push(t.variableDefinition({
+        variable: t.variable({ name: spec.varName }),
+        type: (0, graphql_1.parseType)(spec.typeName),
+    }));
+    args.push(t.argument({
+        name: spec.argName ?? spec.varName,
+        value: t.variable({ name: spec.varName }),
+    }));
+    variables[spec.varName] = spec.value;
+}
+function buildValueAst(value) {
+    if (value === null) {
+        return t.nullValue();
+    }
+    if (typeof value === 'boolean') {
+        return t.booleanValue({ value });
+    }
+    if (typeof value === 'number') {
+        return Number.isInteger(value)
+            ? t.intValue({ value: value.toString() })
+            : t.floatValue({ value: value.toString() });
+    }
+    if (typeof value === 'string') {
+        return t.stringValue({ value });
+    }
+    if (Array.isArray(value)) {
+        return t.listValue({
+            values: value.map((item) => buildValueAst(item)),
+        });
+    }
+    if (typeof value === 'object' && value !== null) {
+        const obj = value;
+        return t.objectValue({
+            fields: Object.entries(obj).map(([key, val]) => t.objectField({
+                name: key,
+                value: buildValueAst(val),
+            })),
+        });
+    }
+    throw new Error('Unsupported value type: ' + typeof value);
+}

package/esm/cli/codegen/orm/client-generator.d.ts

@@ -15,6 +15,9 @@ export interface GeneratedClientFile {
 export declare function generateOrmClientFile(): GeneratedClientFile;
 /**
  * Generate the query-builder.ts file (runtime query builder)
+ *
+ * Reads from the actual TypeScript file in the source directory,
+ * which enables proper type checking and testability.
  */
 export declare function generateQueryBuilderFile(): GeneratedClientFile;
 /**