@constructive-io/graphql-codegen 2.18.0 → 2.20.0

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

@@ -0,0 +1,353 @@
+/**
+ * Runtime query builder for ORM client
+ *
+ * This module provides the runtime functionality that builds GraphQL
+ * queries/mutations from the fluent API calls and executes them.
+ *
+ * This file will be copied to the generated output (not generated via AST)
+ * since it's runtime code that doesn't change based on schema.
+ */
+/**
+ * Internal client state
+ */
+export class OrmClient {
+    endpoint;
+    headers;
+    constructor(config) {
+        this.endpoint = config.endpoint;
+        this.headers = config.headers ?? {};
+    }
+    /**
+     * Execute a GraphQL query/mutation
+     */
+    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 {
+                data: null,
+                errors: [
+                    {
+                        message: `HTTP ${response.status}: ${response.statusText}`,
+                    },
+                ],
+            };
+        }
+        const json = (await response.json());
+        return {
+            data: json.data ?? null,
+            errors: json.errors,
+        };
+    }
+    /**
+     * Update headers (e.g., for auth token refresh)
+     */
+    setHeaders(headers) {
+        this.headers = { ...this.headers, ...headers };
+    }
+    /**
+     * Get current endpoint
+     */
+    getEndpoint() {
+        return this.endpoint;
+    }
+}
+/**
+ * Query builder that holds the query configuration and executes it
+ *
+ * Usage:
+ * ```typescript
+ * const result = await new QueryBuilder(config).execute();
+ * ```
+ */
+export class QueryBuilder {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Execute the query and return the result
+     */
+    async execute() {
+        return this.config.client.execute(this.config.document, this.config.variables);
+    }
+    /**
+     * Get the GraphQL document (useful for debugging)
+     */
+    toGraphQL() {
+        return this.config.document;
+    }
+    /**
+     * Get the variables (useful for debugging)
+     */
+    getVariables() {
+        return this.config.variables;
+    }
+}
+// ============================================================================
+// GraphQL Document Builders (Runtime)
+// ============================================================================
+/**
+ * Build field selections from a select object
+ *
+ * Converts:
+ * { id: true, name: true, posts: { select: { title: true } } }
+ *
+ * To:
+ * id
+ * name
+ * posts {
+ *   nodes { title }
+ *   totalCount
+ *   pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+ * }
+ */
+export function buildSelections(select, fieldMeta) {
+    if (!select) {
+        return '';
+    }
+    const fields = [];
+    for (const [key, value] of Object.entries(select)) {
+        if (value === false || value === undefined) {
+            continue;
+        }
+        if (value === true) {
+            fields.push(key);
+            continue;
+        }
+        // Nested select
+        if (typeof value === 'object' && value !== null) {
+            const nested = value;
+            const meta = fieldMeta?.[key];
+            const isConnection = meta?.isConnection ?? true; // Default to connection for relations
+            if (nested.select) {
+                const nestedSelections = buildSelections(nested.select);
+                // Build arguments for the relation field
+                const args = [];
+                if (nested.first !== undefined) {
+                    args.push(`first: ${nested.first}`);
+                }
+                if (nested.filter) {
+                    args.push(`filter: ${JSON.stringify(nested.filter)}`);
+                }
+                if (nested.orderBy && nested.orderBy.length > 0) {
+                    args.push(`orderBy: [${nested.orderBy.join(', ')}]`);
+                }
+                const argsStr = args.length > 0 ? `(${args.join(', ')})` : '';
+                if (isConnection) {
+                    // Connection type - include nodes, totalCount, pageInfo
+                    fields.push(`${key}${argsStr} {
+      nodes { ${nestedSelections} }
+      totalCount
+      pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+    }`);
+                }
+                else {
+                    // Direct relation (not a connection)
+                    fields.push(`${key}${argsStr} { ${nestedSelections} }`);
+                }
+            }
+        }
+    }
+    return fields.join('\n    ');
+}
+/**
+ * Build a findMany query document
+ */
+export function buildFindManyDocument(operationName, queryField, select, args, filterTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    // Build variable definitions and query arguments
+    const varDefs = [];
+    const queryArgs = [];
+    const variables = {};
+    if (args.where) {
+        varDefs.push(`$where: ${filterTypeName}`);
+        queryArgs.push('filter: $where');
+        variables.where = args.where;
+    }
+    if (args.orderBy && args.orderBy.length > 0) {
+        varDefs.push(`$orderBy: [${operationName}OrderBy!]`);
+        queryArgs.push('orderBy: $orderBy');
+        variables.orderBy = args.orderBy;
+    }
+    if (args.first !== undefined) {
+        varDefs.push('$first: Int');
+        queryArgs.push('first: $first');
+        variables.first = args.first;
+    }
+    if (args.last !== undefined) {
+        varDefs.push('$last: Int');
+        queryArgs.push('last: $last');
+        variables.last = args.last;
+    }
+    if (args.after) {
+        varDefs.push('$after: Cursor');
+        queryArgs.push('after: $after');
+        variables.after = args.after;
+    }
+    if (args.before) {
+        varDefs.push('$before: Cursor');
+        queryArgs.push('before: $before');
+        variables.before = args.before;
+    }
+    if (args.offset !== undefined) {
+        varDefs.push('$offset: Int');
+        queryArgs.push('offset: $offset');
+        variables.offset = args.offset;
+    }
+    const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(', ')})` : '';
+    const queryArgsStr = queryArgs.length > 0 ? `(${queryArgs.join(', ')})` : '';
+    const document = `query ${operationName}Query${varDefsStr} {
+  ${queryField}${queryArgsStr} {
+    nodes {
+      ${selections}
+    }
+    totalCount
+    pageInfo {
+      hasNextPage
+      hasPreviousPage
+      startCursor
+      endCursor
+    }
+  }
+}`;
+    return { document, variables };
+}
+/**
+ * Build a findFirst query document
+ */
+export function buildFindFirstDocument(operationName, queryField, select, args, filterTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    const varDefs = [];
+    const queryArgs = [];
+    const variables = {};
+    if (args.where) {
+        varDefs.push(`$where: ${filterTypeName}`);
+        queryArgs.push('filter: $where');
+        variables.where = args.where;
+    }
+    // findFirst uses the list query with first: 1
+    varDefs.push('$first: Int');
+    queryArgs.push('first: $first');
+    variables.first = 1;
+    const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(', ')})` : '';
+    const queryArgsStr = queryArgs.length > 0 ? `(${queryArgs.join(', ')})` : '';
+    const document = `query ${operationName}Query${varDefsStr} {
+  ${queryField}${queryArgsStr} {
+    nodes {
+      ${selections}
+    }
+  }
+}`;
+    return { document, variables };
+}
+/**
+ * Build a create mutation document
+ */
+export function buildCreateDocument(operationName, mutationField, entityField, select, data, inputTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    const document = `mutation ${operationName}Mutation($input: ${inputTypeName}!) {
+  ${mutationField}(input: $input) {
+    ${entityField} {
+      ${selections}
+    }
+  }
+}`;
+    return {
+        document,
+        variables: {
+            input: {
+                [entityField]: data,
+            },
+        },
+    };
+}
+/**
+ * Build an update mutation document
+ */
+export function buildUpdateDocument(operationName, mutationField, entityField, select, where, data, inputTypeName) {
+    const selections = select ? buildSelections(select) : 'id';
+    // PostGraphile update uses nodeId or primary key in input
+    const document = `mutation ${operationName}Mutation($input: ${inputTypeName}!) {
+  ${mutationField}(input: $input) {
+    ${entityField} {
+      ${selections}
+    }
+  }
+}`;
+    return {
+        document,
+        variables: {
+            input: {
+                id: where.id, // Assumes id-based where clause
+                patch: data,
+            },
+        },
+    };
+}
+/**
+ * Build a delete mutation document
+ */
+export function buildDeleteDocument(operationName, mutationField, entityField, where, inputTypeName) {
+    const document = `mutation ${operationName}Mutation($input: ${inputTypeName}!) {
+  ${mutationField}(input: $input) {
+    ${entityField} {
+      id
+    }
+  }
+}`;
+    return {
+        document,
+        variables: {
+            input: {
+                id: where.id,
+            },
+        },
+    };
+}
+/**
+ * Build a custom query document
+ */
+export function buildCustomQueryDocument(operationName, queryField, select, args, variableDefinitions) {
+    const selections = select ? buildSelections(select) : '';
+    const varDefs = variableDefinitions.map((v) => `$${v.name}: ${v.type}`);
+    const queryArgs = variableDefinitions.map((v) => `${v.name}: $${v.name}`);
+    const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(', ')})` : '';
+    const queryArgsStr = queryArgs.length > 0 ? `(${queryArgs.join(', ')})` : '';
+    const selectionsBlock = selections ? ` {\n      ${selections}\n    }` : '';
+    const document = `query ${operationName}Query${varDefsStr} {
+  ${queryField}${queryArgsStr}${selectionsBlock}
+}`;
+    return {
+        document,
+        variables: args ?? {},
+    };
+}
+/**
+ * Build a custom mutation document
+ */
+export function buildCustomMutationDocument(operationName, mutationField, select, args, variableDefinitions) {
+    const selections = select ? buildSelections(select) : '';
+    const varDefs = variableDefinitions.map((v) => `$${v.name}: ${v.type}`);
+    const mutationArgs = variableDefinitions.map((v) => `${v.name}: $${v.name}`);
+    const varDefsStr = varDefs.length > 0 ? `(${varDefs.join(', ')})` : '';
+    const mutationArgsStr = mutationArgs.length > 0 ? `(${mutationArgs.join(', ')})` : '';
+    const selectionsBlock = selections ? ` {\n      ${selections}\n    }` : '';
+    const document = `mutation ${operationName}Mutation${varDefsStr} {
+  ${mutationField}${mutationArgsStr}${selectionsBlock}
+}`;
+    return {
+        document,
+        variables: args ?? {},
+    };
+}

package/esm/cli/codegen/orm/select-types.d.ts

@@ -0,0 +1,169 @@
+/**
+ * TypeScript utility types for ORM select inference
+ *
+ * These types enable Prisma-like type inference where the return type
+ * is automatically derived from the `select` object passed to queries.
+ *
+ * Example:
+ * ```typescript
+ * const user = await db.user.findFirst({
+ *   select: { id: true, name: true }
+ * }).execute();
+ * // user type is { id: string; name: string } | null
+ * ```
+ */
+/**
+ * Extracts the element type from an array or connection type
+ */
+export type ElementType<T> = T extends (infer E)[] ? E : T extends {
+    nodes: (infer E)[];
+} ? E : T;
+/**
+ * Checks if a type is a connection type (has nodes array)
+ */
+export type IsConnection<T> = T extends {
+    nodes: unknown[];
+    totalCount: number;
+} ? true : false;
+/**
+ * Base select type - maps fields to boolean or nested select config
+ * This is generated per-entity
+ */
+export type SelectConfig<TFields extends string> = {
+    [K in TFields]?: boolean | NestedSelectConfig;
+};
+/**
+ * Nested select configuration for relations
+ */
+export interface NestedSelectConfig {
+    select?: Record<string, boolean | NestedSelectConfig>;
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    filter?: Record<string, unknown>;
+    orderBy?: string[];
+}
+/**
+ * Infers the result type from a select configuration
+ *
+ * Rules:
+ * - If field is `true`, include the field with its original type
+ * - If field is `false` or not present, exclude the field
+ * - If field is an object with `select`, recursively apply inference
+ * - For connection types, preserve the connection structure
+ */
+export type InferSelectResult<TEntity, TSelect> = TSelect extends undefined ? TEntity : {
+    [K in keyof TSelect as TSelect[K] extends false | undefined ? never : K]: TSelect[K] extends true ? K extends keyof TEntity ? TEntity[K] : never : TSelect[K] extends {
+        select: infer NestedSelect;
+    } ? K extends keyof TEntity ? NonNullable<TEntity[K]> extends ConnectionResult<infer NodeType> ? ConnectionResult<InferSelectResult<NodeType, NestedSelect>> : InferSelectResult<NonNullable<TEntity[K]>, NestedSelect> | (null extends TEntity[K] ? null : never) : never : K extends keyof TEntity ? TEntity[K] : never;
+};
+/**
+ * Makes all properties in the result optional for partial selects
+ * Used when select is not provided (returns all fields)
+ */
+export type PartialEntity<T> = {
+    [K in keyof T]?: T[K];
+};
+/**
+ * Result wrapper that matches GraphQL response structure
+ */
+export interface QueryResult<T> {
+    data: T | null;
+    errors?: GraphQLError[];
+}
+/**
+ * GraphQL error type
+ */
+export interface GraphQLError {
+    message: string;
+    locations?: {
+        line: number;
+        column: number;
+    }[];
+    path?: (string | number)[];
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Connection result type for list queries
+ */
+export interface ConnectionResult<T> {
+    nodes: T[];
+    totalCount: number;
+    pageInfo: PageInfo;
+}
+/**
+ * PageInfo type from GraphQL connections
+ */
+export interface PageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor?: string | null;
+    endCursor?: string | null;
+}
+/**
+ * Arguments for findMany operations
+ */
+export interface FindManyArgs<TSelect, TWhere, TOrderBy> {
+    select?: TSelect;
+    where?: TWhere;
+    orderBy?: TOrderBy[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}
+/**
+ * Arguments for findFirst/findUnique operations
+ */
+export interface FindFirstArgs<TSelect, TWhere> {
+    select?: TSelect;
+    where?: TWhere;
+}
+/**
+ * Arguments for create operations
+ */
+export interface CreateArgs<TSelect, TData> {
+    data: TData;
+    select?: TSelect;
+}
+/**
+ * Arguments for update operations
+ */
+export interface UpdateArgs<TSelect, TWhere, TData> {
+    where: TWhere;
+    data: TData;
+    select?: TSelect;
+}
+/**
+ * Arguments for delete operations
+ */
+export interface DeleteArgs<TWhere> {
+    where: TWhere;
+}
+/**
+ * Helper type to get the final result type from a query
+ * Handles the case where select is optional
+ */
+export type ResolveSelectResult<TEntity, TSelect> = TSelect extends undefined ? TEntity : InferSelectResult<TEntity, NonNullable<TSelect>>;
+/**
+ * Type for operation that returns a single entity or null
+ */
+export type SingleResult<TEntity, TSelect> = QueryResult<{
+    [K: string]: ResolveSelectResult<TEntity, TSelect> | null;
+}>;
+/**
+ * Type for operation that returns a connection
+ */
+export type ConnectionQueryResult<TEntity, TSelect> = QueryResult<{
+    [K: string]: ConnectionResult<ResolveSelectResult<TEntity, TSelect>>;
+}>;
+/**
+ * Type for mutation that returns a payload with the entity
+ */
+export type MutationResult<TEntity, TSelect, TPayloadKey extends string> = QueryResult<{
+    [K in TPayloadKey]: {
+        [EntityKey: string]: ResolveSelectResult<TEntity, TSelect>;
+    };
+}>;

package/esm/cli/codegen/orm/select-types.js

@@ -0,0 +1,15 @@
+/**
+ * TypeScript utility types for ORM select inference
+ *
+ * These types enable Prisma-like type inference where the return type
+ * is automatically derived from the `select` object passed to queries.
+ *
+ * Example:
+ * ```typescript
+ * const user = await db.user.findFirst({
+ *   select: { id: true, name: true }
+ * }).execute();
+ * // user type is { id: string; name: string } | null
+ * ```
+ */
+export {};

package/esm/cli/codegen/orm/select-types.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Type-level tests for select-types.ts
+ *
+ * These tests verify the compile-time type inference behavior.
+ * The TypeScript compiler validates these types during build.
+ *
+ * Note: Type-only tests using expectTypeOf have been removed as they
+ * are not compatible with Jest. The TypeScript compiler validates
+ * these types at compile time via the type assertions below.
+ */
+export {};

package/esm/cli/codegen/orm/select-types.test.js

@@ -0,0 +1,21 @@
+/**
+ * Type-level tests for select-types.ts
+ *
+ * These tests verify the compile-time type inference behavior.
+ * The TypeScript compiler validates these types during build.
+ *
+ * Note: Type-only tests using expectTypeOf have been removed as they
+ * are not compatible with Jest. The TypeScript compiler validates
+ * these types at compile time via the type assertions below.
+ */
+// Compile-time type check: verify the inferred type matches expected structure
+const _typeCheck = {};
+const _excludedTypeCheck = {};
+// Dummy test to satisfy Jest
+describe('InferSelectResult', () => {
+    it('type assertions compile correctly', () => {
+        // If this file compiles, the type tests pass
+        expect(true).toBe(true);
+    });
+});
+export {};

package/esm/cli/codegen/queries.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Query hook generators using AST-based code generation
+ *
+ * Output structure:
+ * queries/
+ *   useCarsQuery.ts    - List query hook
+ *   useCarQuery.ts     - Single item query hook
+ */
+import type { CleanTable } from '../../types/schema';
+export interface GeneratedQueryFile {
+    fileName: string;
+    content: string;
+}
+/**
+ * Generate list query hook file content using AST
+ */
+export declare function generateListQueryHook(table: CleanTable): GeneratedQueryFile;
+/**
+ * Generate single item query hook file content using AST
+ */
+export declare function generateSingleQueryHook(table: CleanTable): GeneratedQueryFile;
+/**
+ * Generate all query hook files for all tables
+ */
+export declare function generateAllQueryHooks(tables: CleanTable[]): GeneratedQueryFile[];