@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/cli/codegen/gql-ast.js

@@ -0,0 +1,329 @@
+"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 orderByType = (0, utils_1.getOrderByTypeName)(table);
+    const scalarFields = (0, utils_1.getScalarFields)(table);
+    // Variable definitions
+    const variableDefinitions = [
+        t.variableDefinition({
+            variable: t.variable({ name: 'first' }),
+            type: t.namedType({ type: 'Int' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'offset' }),
+            type: t.namedType({ type: 'Int' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'filter' }),
+            type: t.namedType({ type: filterType }),
+        }),
+        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: 'offset', value: t.variable({ name: 'offset' }) }),
+        t.argument({ name: 'filter', value: t.variable({ name: 'filter' }) }),
+        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);
+    // Variable definitions - assume UUID primary key
+    const variableDefinitions = [
+        t.variableDefinition({
+            variable: t.variable({ name: 'id' }),
+            type: t.nonNullType({ type: t.namedType({ type: 'UUID' }) }),
+        }),
+    ];
+    // Query arguments
+    const args = [
+        t.argument({ name: 'id', value: t.variable({ name: 'id' }) }),
+    ];
+    // 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' }),
+                                    t.field({ name: 'deletedId' }),
+                                ],
+                            }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+}
+// ============================================================================
+// Print utilities
+// ============================================================================
+/**
+ * Print AST to GraphQL string
+ */
+function printGraphQL(ast) {
+    return (0, graphql_1.print)(ast);
+}

package/cli/codegen/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Code generation orchestrator
+ *
+ * Coordinates all code generators to produce the complete SDK output.
+ *
+ * Output structure:
+ * generated/
+ *   index.ts              - Main barrel export
+ *   client.ts             - GraphQL client with configure() and execute()
+ *   types.ts              - Entity interfaces and filter types
+ *   queries/
+ *     index.ts            - Query hooks barrel
+ *     useCarsQuery.ts     - List query hook (table-based)
+ *     useCarQuery.ts      - Single item query hook (table-based)
+ *     useCurrentUserQuery.ts - Custom query hook
+ *     ...
+ *   mutations/
+ *     index.ts            - Mutation hooks barrel
+ *     useCreateCarMutation.ts  - Table-based CRUD
+ *     useUpdateCarMutation.ts
+ *     useDeleteCarMutation.ts
+ *     useLoginMutation.ts      - Custom mutation
+ *     useRegisterMutation.ts
+ *     ...
+ */
+import type { CleanTable, CleanOperation, TypeRegistry } from '../../types/schema';
+import type { ResolvedConfig } from '../../types/config';
+export interface GeneratedFile {
+    /** Relative path from output directory */
+    path: string;
+    /** File content */
+    content: string;
+}
+export interface GenerateResult {
+    files: GeneratedFile[];
+    stats: {
+        tables: number;
+        queryHooks: number;
+        mutationHooks: number;
+        customQueryHooks: number;
+        customMutationHooks: number;
+        totalFiles: number;
+    };
+}
+export interface GenerateOptions {
+    /** Tables from _meta introspection */
+    tables: CleanTable[];
+    /** Custom operations from __schema introspection */
+    customOperations?: {
+        queries: CleanOperation[];
+        mutations: CleanOperation[];
+        typeRegistry: TypeRegistry;
+    };
+    /** Resolved configuration */
+    config: ResolvedConfig;
+}
+/**
+ * Generate all SDK files for tables only (legacy function signature)
+ */
+export declare function generateAllFiles(tables: CleanTable[], config: ResolvedConfig): GenerateResult;
+/**
+ * Generate all SDK files with full support for custom operations
+ */
+export declare function generate(options: GenerateOptions): GenerateResult;
+export { generateClientFile } from './client';
+export { generateTypesFile } from './types';
+export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook } from './queries';
+export { generateAllMutationHooks, generateCreateMutationHook, generateUpdateMutationHook, generateDeleteMutationHook, } from './mutations';
+export { generateAllCustomQueryHooks, generateCustomQueryHook } from './custom-queries';
+export { generateAllCustomMutationHooks, generateCustomMutationHook } from './custom-mutations';
+export { generateQueriesBarrel, generateMutationsBarrel, generateMainBarrel, generateCustomQueriesBarrel, generateCustomMutationsBarrel, } from './barrel';

package/cli/codegen/index.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCustomMutationsBarrel = exports.generateCustomQueriesBarrel = exports.generateMainBarrel = exports.generateMutationsBarrel = exports.generateQueriesBarrel = exports.generateCustomMutationHook = exports.generateAllCustomMutationHooks = exports.generateCustomQueryHook = exports.generateAllCustomQueryHooks = exports.generateDeleteMutationHook = exports.generateUpdateMutationHook = exports.generateCreateMutationHook = exports.generateAllMutationHooks = exports.generateSingleQueryHook = exports.generateListQueryHook = exports.generateAllQueryHooks = exports.generateTypesFile = exports.generateClientFile = void 0;
+exports.generateAllFiles = generateAllFiles;
+exports.generate = generate;
+const client_1 = require("./client");
+const types_1 = require("./types");
+const queries_1 = require("./queries");
+const mutations_1 = require("./mutations");
+const custom_queries_1 = require("./custom-queries");
+const custom_mutations_1 = require("./custom-mutations");
+const barrel_1 = require("./barrel");
+// ============================================================================
+// Main orchestrator
+// ============================================================================
+/**
+ * Generate all SDK files for tables only (legacy function signature)
+ */
+function generateAllFiles(tables, config) {
+    return generate({ tables, config });
+}
+/**
+ * Generate all SDK files with full support for custom operations
+ */
+function generate(options) {
+    const { tables, customOperations, config } = options;
+    const files = [];
+    // Extract codegen options
+    const maxDepth = config.codegen.maxFieldDepth;
+    const skipQueryField = config.codegen.skipQueryField;
+    // 1. Generate client.ts
+    files.push({
+        path: 'client.ts',
+        content: (0, client_1.generateClientFile)(),
+    });
+    // 2. Generate types.ts
+    files.push({
+        path: 'types.ts',
+        content: (0, types_1.generateTypesFile)(tables),
+    });
+    // 3. Generate table-based query hooks (queries/*.ts)
+    const queryHooks = (0, queries_1.generateAllQueryHooks)(tables);
+    for (const hook of queryHooks) {
+        files.push({
+            path: `queries/${hook.fileName}`,
+            content: hook.content,
+        });
+    }
+    // 4. Generate custom query hooks if available
+    let customQueryHooks = [];
+    if (customOperations && customOperations.queries.length > 0) {
+        customQueryHooks = (0, custom_queries_1.generateAllCustomQueryHooks)({
+            operations: customOperations.queries,
+            typeRegistry: customOperations.typeRegistry,
+            maxDepth,
+            skipQueryField,
+        });
+        for (const hook of customQueryHooks) {
+            files.push({
+                path: `queries/${hook.fileName}`,
+                content: hook.content,
+            });
+        }
+    }
+    // 5. Generate queries/index.ts barrel (includes both table and custom queries)
+    files.push({
+        path: 'queries/index.ts',
+        content: customQueryHooks.length > 0
+            ? (0, barrel_1.generateCustomQueriesBarrel)(tables, customQueryHooks.map((h) => h.operationName))
+            : (0, barrel_1.generateQueriesBarrel)(tables),
+    });
+    // 6. Generate table-based mutation hooks (mutations/*.ts)
+    const mutationHooks = (0, mutations_1.generateAllMutationHooks)(tables);
+    for (const hook of mutationHooks) {
+        files.push({
+            path: `mutations/${hook.fileName}`,
+            content: hook.content,
+        });
+    }
+    // 7. Generate custom mutation hooks if available
+    let customMutationHooks = [];
+    if (customOperations && customOperations.mutations.length > 0) {
+        customMutationHooks = (0, custom_mutations_1.generateAllCustomMutationHooks)({
+            operations: customOperations.mutations,
+            typeRegistry: customOperations.typeRegistry,
+            maxDepth,
+            skipQueryField,
+        });
+        for (const hook of customMutationHooks) {
+            files.push({
+                path: `mutations/${hook.fileName}`,
+                content: hook.content,
+            });
+        }
+    }
+    // 8. Generate mutations/index.ts barrel (includes both table and custom mutations)
+    files.push({
+        path: 'mutations/index.ts',
+        content: customMutationHooks.length > 0
+            ? (0, barrel_1.generateCustomMutationsBarrel)(tables, customMutationHooks.map((h) => h.operationName))
+            : (0, barrel_1.generateMutationsBarrel)(tables),
+    });
+    // 9. Generate main index.ts barrel
+    files.push({
+        path: 'index.ts',
+        content: (0, barrel_1.generateMainBarrel)(tables),
+    });
+    return {
+        files,
+        stats: {
+            tables: tables.length,
+            queryHooks: queryHooks.length,
+            mutationHooks: mutationHooks.length,
+            customQueryHooks: customQueryHooks.length,
+            customMutationHooks: customMutationHooks.length,
+            totalFiles: files.length,
+        },
+    };
+}
+// ============================================================================
+// Re-exports for convenience
+// ============================================================================
+var client_2 = require("./client");
+Object.defineProperty(exports, "generateClientFile", { enumerable: true, get: function () { return client_2.generateClientFile; } });
+var types_2 = require("./types");
+Object.defineProperty(exports, "generateTypesFile", { enumerable: true, get: function () { return types_2.generateTypesFile; } });
+var queries_2 = require("./queries");
+Object.defineProperty(exports, "generateAllQueryHooks", { enumerable: true, get: function () { return queries_2.generateAllQueryHooks; } });
+Object.defineProperty(exports, "generateListQueryHook", { enumerable: true, get: function () { return queries_2.generateListQueryHook; } });
+Object.defineProperty(exports, "generateSingleQueryHook", { enumerable: true, get: function () { return queries_2.generateSingleQueryHook; } });
+var mutations_2 = require("./mutations");
+Object.defineProperty(exports, "generateAllMutationHooks", { enumerable: true, get: function () { return mutations_2.generateAllMutationHooks; } });
+Object.defineProperty(exports, "generateCreateMutationHook", { enumerable: true, get: function () { return mutations_2.generateCreateMutationHook; } });
+Object.defineProperty(exports, "generateUpdateMutationHook", { enumerable: true, get: function () { return mutations_2.generateUpdateMutationHook; } });
+Object.defineProperty(exports, "generateDeleteMutationHook", { enumerable: true, get: function () { return mutations_2.generateDeleteMutationHook; } });
+var custom_queries_2 = require("./custom-queries");
+Object.defineProperty(exports, "generateAllCustomQueryHooks", { enumerable: true, get: function () { return custom_queries_2.generateAllCustomQueryHooks; } });
+Object.defineProperty(exports, "generateCustomQueryHook", { enumerable: true, get: function () { return custom_queries_2.generateCustomQueryHook; } });
+var custom_mutations_2 = require("./custom-mutations");
+Object.defineProperty(exports, "generateAllCustomMutationHooks", { enumerable: true, get: function () { return custom_mutations_2.generateAllCustomMutationHooks; } });
+Object.defineProperty(exports, "generateCustomMutationHook", { enumerable: true, get: function () { return custom_mutations_2.generateCustomMutationHook; } });
+var barrel_2 = require("./barrel");
+Object.defineProperty(exports, "generateQueriesBarrel", { enumerable: true, get: function () { return barrel_2.generateQueriesBarrel; } });
+Object.defineProperty(exports, "generateMutationsBarrel", { enumerable: true, get: function () { return barrel_2.generateMutationsBarrel; } });
+Object.defineProperty(exports, "generateMainBarrel", { enumerable: true, get: function () { return barrel_2.generateMainBarrel; } });
+Object.defineProperty(exports, "generateCustomQueriesBarrel", { enumerable: true, get: function () { return barrel_2.generateCustomQueriesBarrel; } });
+Object.defineProperty(exports, "generateCustomMutationsBarrel", { enumerable: true, get: function () { return barrel_2.generateCustomMutationsBarrel; } });

package/cli/codegen/mutations.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Mutation hook generators using AST-based code generation
+ *
+ * Output structure:
+ * mutations/
+ *   useCreateCarMutation.ts
+ *   useUpdateCarMutation.ts
+ *   useDeleteCarMutation.ts
+ */
+import type { CleanTable } from '../../types/schema';
+export interface GeneratedMutationFile {
+    fileName: string;
+    content: string;
+}
+/**
+ * Generate create mutation hook file content using AST
+ */
+export declare function generateCreateMutationHook(table: CleanTable): GeneratedMutationFile;
+/**
+ * Generate update mutation hook file content using AST
+ */
+export declare function generateUpdateMutationHook(table: CleanTable): GeneratedMutationFile | null;
+/**
+ * Generate delete mutation hook file content using AST
+ */
+export declare function generateDeleteMutationHook(table: CleanTable): GeneratedMutationFile | null;
+/**
+ * Generate all mutation hook files for all tables
+ */
+export declare function generateAllMutationHooks(tables: CleanTable[]): GeneratedMutationFile[];