@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/cli/commands/generate-orm.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Generate ORM command - generates Prisma-like ORM client
+ *
+ * This command:
+ * 1. Fetches _meta query for table-based CRUD operations
+ * 2. Fetches __schema introspection for custom operations
+ * 3. Generates a Prisma-like ORM client with fluent API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOrmCommand = generateOrmCommand;
+const config_1 = require("../../types/config");
+const fetch_meta_1 = require("../introspect/fetch-meta");
+const fetch_schema_1 = require("../introspect/fetch-schema");
+const transform_1 = require("../introspect/transform");
+const transform_schema_1 = require("../introspect/transform-schema");
+const init_1 = require("./init");
+const generate_1 = require("./generate");
+const orm_1 = require("../codegen/orm");
+/**
+ * Execute the generate-orm command
+ */
+async function generateOrmCommand(options = {}) {
+    const log = options.verbose ? console.log : () => { };
+    // 1. Load config
+    log('Loading configuration...');
+    const configResult = await loadConfig(options);
+    if (!configResult.success) {
+        return {
+            success: false,
+            message: configResult.error,
+        };
+    }
+    const config = configResult.config;
+    // Use ORM output directory if specified, otherwise default
+    const outputDir = options.output || config.orm?.output || './generated/orm';
+    log(`  Endpoint: ${config.endpoint}`);
+    log(`  Output: ${outputDir}`);
+    // 2. Validate endpoint
+    const endpointValidation = (0, fetch_meta_1.validateEndpoint)(config.endpoint);
+    if (!endpointValidation.valid) {
+        return {
+            success: false,
+            message: `Invalid endpoint: ${endpointValidation.error}`,
+        };
+    }
+    // Build authorization header if provided
+    const authHeader = options.authorization || config.headers['Authorization'];
+    // 3. Fetch _meta for table-based operations
+    log('Fetching schema metadata (_meta)...');
+    const metaResult = await (0, fetch_meta_1.fetchMeta)({
+        endpoint: config.endpoint,
+        authorization: authHeader,
+        headers: config.headers,
+        timeout: 30000,
+    });
+    if (!metaResult.success) {
+        return {
+            success: false,
+            message: `Failed to fetch _meta: ${metaResult.error}`,
+        };
+    }
+    // 4. Transform to CleanTable[]
+    log('Transforming table schema...');
+    let tables = (0, transform_1.transformMetaToCleanTables)(metaResult.data);
+    log(`  Found ${tables.length} tables`);
+    // 5. Filter tables
+    tables = (0, transform_1.filterTables)(tables, config.tables.include, config.tables.exclude);
+    log(`  After filtering: ${tables.length} tables`);
+    if (tables.length === 0) {
+        return {
+            success: false,
+            message: 'No tables found after filtering. Check your include/exclude patterns.',
+        };
+    }
+    // Get table operation names for filtering custom operations
+    const tableOperationNames = (0, transform_schema_1.getTableOperationNames)(tables);
+    // 6. Fetch __schema for custom operations (unless skipped)
+    let customQueries = [];
+    let customMutations = [];
+    let customOperationsData;
+    if (!options.skipCustomOperations) {
+        log('Fetching schema introspection (__schema)...');
+        const schemaResult = await (0, fetch_schema_1.fetchSchema)({
+            endpoint: config.endpoint,
+            authorization: authHeader,
+            headers: config.headers,
+            timeout: 30000,
+        });
+        if (schemaResult.success && schemaResult.data) {
+            log('Transforming custom operations...');
+            // Transform to CleanOperation[]
+            const { queries: allQueries, mutations: allMutations, typeRegistry } = (0, transform_schema_1.transformSchemaToOperations)(schemaResult.data);
+            log(`  Found ${allQueries.length} queries and ${allMutations.length} mutations total`);
+            // Filter by config include/exclude
+            const filteredQueries = (0, transform_schema_1.filterOperations)(allQueries, config.queries.include, config.queries.exclude);
+            const filteredMutations = (0, transform_schema_1.filterOperations)(allMutations, config.mutations.include, config.mutations.exclude);
+            log(`  After config filtering: ${filteredQueries.length} queries, ${filteredMutations.length} mutations`);
+            // Remove table operations (already handled by table generators)
+            const customQueriesOps = (0, transform_schema_1.getCustomOperations)(filteredQueries, tableOperationNames);
+            const customMutationsOps = (0, transform_schema_1.getCustomOperations)(filteredMutations, tableOperationNames);
+            log(`  Custom operations: ${customQueriesOps.length} queries, ${customMutationsOps.length} mutations`);
+            customQueries = customQueriesOps.map((q) => q.name);
+            customMutations = customMutationsOps.map((m) => m.name);
+            customOperationsData = {
+                queries: customQueriesOps,
+                mutations: customMutationsOps,
+                typeRegistry,
+            };
+        }
+        else {
+            log(`  Warning: Could not fetch __schema: ${schemaResult.error}`);
+            log('  Continuing with table-only generation...');
+        }
+    }
+    // 7. Generate ORM code
+    log('Generating ORM client...');
+    const { files: generatedFiles, stats } = (0, orm_1.generateOrm)({
+        tables,
+        customOperations: customOperationsData,
+        config,
+    });
+    log(`  Generated ${stats.tables} table models`);
+    log(`  Generated ${stats.customQueries} custom query operations`);
+    log(`  Generated ${stats.customMutations} custom mutation operations`);
+    log(`  Total files: ${stats.totalFiles}`);
+    if (options.dryRun) {
+        return {
+            success: true,
+            message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${customQueries.length + customMutations.length} custom operations.`,
+            tables: tables.map((t) => t.name),
+            customQueries,
+            customMutations,
+            filesWritten: generatedFiles.map((f) => f.path),
+        };
+    }
+    // 8. Write files
+    log('Writing files...');
+    const writeResult = await (0, generate_1.writeGeneratedFiles)(generatedFiles, outputDir, ['models', 'query', 'mutation']);
+    if (!writeResult.success) {
+        return {
+            success: false,
+            message: `Failed to write files: ${writeResult.errors?.join(', ')}`,
+            errors: writeResult.errors,
+        };
+    }
+    const totalOps = customQueries.length + customMutations.length;
+    const customOpsMsg = totalOps > 0 ? ` and ${totalOps} custom operations` : '';
+    return {
+        success: true,
+        message: `Generated ORM client for ${tables.length} tables${customOpsMsg}. Files written to ${outputDir}`,
+        tables: tables.map((t) => t.name),
+        customQueries,
+        customMutations,
+        filesWritten: writeResult.filesWritten,
+    };
+}
+async function loadConfig(options) {
+    // Find config file
+    let configPath = options.config;
+    if (!configPath) {
+        configPath = (0, init_1.findConfigFile)() ?? undefined;
+    }
+    let baseConfig = {};
+    if (configPath) {
+        const loadResult = await (0, init_1.loadConfigFile)(configPath);
+        if (!loadResult.success) {
+            return { success: false, error: loadResult.error };
+        }
+        baseConfig = loadResult.config;
+    }
+    // Override with CLI options
+    const mergedConfig = {
+        endpoint: options.endpoint || baseConfig.endpoint || '',
+        output: options.output || baseConfig.output,
+        headers: baseConfig.headers,
+        tables: baseConfig.tables,
+        queries: baseConfig.queries,
+        mutations: baseConfig.mutations,
+        excludeFields: baseConfig.excludeFields,
+        hooks: baseConfig.hooks,
+        postgraphile: baseConfig.postgraphile,
+        codegen: baseConfig.codegen,
+        orm: baseConfig.orm,
+    };
+    if (!mergedConfig.endpoint) {
+        return {
+            success: false,
+            error: 'No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".',
+        };
+    }
+    // Resolve with defaults
+    const config = (0, config_1.resolveConfig)(mergedConfig);
+    return { success: true, config };
+}

package/cli/commands/generate.d.ts

@@ -0,0 +1,39 @@
+export interface GenerateOptions {
+    /** Path to config file */
+    config?: string;
+    /** GraphQL endpoint URL (overrides config) */
+    endpoint?: string;
+    /** Output directory (overrides config) */
+    output?: string;
+    /** Authorization header */
+    authorization?: string;
+    /** Verbose output */
+    verbose?: boolean;
+    /** Dry run - don't write files */
+    dryRun?: boolean;
+    /** Skip custom operations (only generate table CRUD) */
+    skipCustomOperations?: boolean;
+}
+export interface GenerateResult {
+    success: boolean;
+    message: string;
+    tables?: string[];
+    customQueries?: string[];
+    customMutations?: string[];
+    filesWritten?: string[];
+    errors?: string[];
+}
+/**
+ * Execute the generate command
+ */
+export declare function generateCommand(options?: GenerateOptions): Promise<GenerateResult>;
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export interface WriteResult {
+    success: boolean;
+    filesWritten?: string[];
+    errors?: string[];
+}
+export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[]): Promise<WriteResult>;

package/cli/commands/generate.js

@@ -0,0 +1,299 @@
+"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.generateCommand = generateCommand;
+exports.writeGeneratedFiles = writeGeneratedFiles;
+/**
+ * Generate command - introspects endpoint and generates SDK
+ *
+ * This command:
+ * 1. Fetches _meta query for table-based CRUD operations
+ * 2. Fetches __schema introspection for ALL operations
+ * 3. Filters out table operations from custom operations to avoid duplicates
+ * 4. Generates hooks for both table CRUD and custom operations
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const prettier = __importStar(require("prettier"));
+const config_1 = require("../../types/config");
+const fetch_meta_1 = require("../introspect/fetch-meta");
+const fetch_schema_1 = require("../introspect/fetch-schema");
+const transform_1 = require("../introspect/transform");
+const transform_schema_1 = require("../introspect/transform-schema");
+const init_1 = require("./init");
+const codegen_1 = require("../codegen");
+/**
+ * Execute the generate command
+ */
+async function generateCommand(options = {}) {
+    const log = options.verbose ? console.log : () => { };
+    // 1. Load config
+    log('Loading configuration...');
+    const configResult = await loadConfig(options);
+    if (!configResult.success) {
+        return {
+            success: false,
+            message: configResult.error,
+        };
+    }
+    const config = configResult.config;
+    log(`  Endpoint: ${config.endpoint}`);
+    log(`  Output: ${config.output}`);
+    // 2. Validate endpoint
+    const endpointValidation = (0, fetch_meta_1.validateEndpoint)(config.endpoint);
+    if (!endpointValidation.valid) {
+        return {
+            success: false,
+            message: `Invalid endpoint: ${endpointValidation.error}`,
+        };
+    }
+    // Build authorization header if provided
+    const authHeader = options.authorization || config.headers['Authorization'];
+    // 3. Fetch _meta for table-based operations
+    log('Fetching schema metadata (_meta)...');
+    const metaResult = await (0, fetch_meta_1.fetchMeta)({
+        endpoint: config.endpoint,
+        authorization: authHeader,
+        headers: config.headers,
+        timeout: 30000,
+    });
+    if (!metaResult.success) {
+        return {
+            success: false,
+            message: `Failed to fetch _meta: ${metaResult.error}`,
+        };
+    }
+    // 4. Transform to CleanTable[]
+    log('Transforming table schema...');
+    let tables = (0, transform_1.transformMetaToCleanTables)(metaResult.data);
+    log(`  Found ${tables.length} tables`);
+    // 5. Filter tables
+    tables = (0, transform_1.filterTables)(tables, config.tables.include, config.tables.exclude);
+    log(`  After filtering: ${tables.length} tables`);
+    if (tables.length === 0) {
+        return {
+            success: false,
+            message: 'No tables found after filtering. Check your include/exclude patterns.',
+        };
+    }
+    // Get table operation names for filtering custom operations
+    const tableOperationNames = (0, transform_schema_1.getTableOperationNames)(tables);
+    // 6. Fetch __schema for custom operations (unless skipped)
+    let customQueries = [];
+    let customMutations = [];
+    let customOperationsData;
+    if (!options.skipCustomOperations) {
+        log('Fetching schema introspection (__schema)...');
+        const schemaResult = await (0, fetch_schema_1.fetchSchema)({
+            endpoint: config.endpoint,
+            authorization: authHeader,
+            headers: config.headers,
+            timeout: 30000,
+        });
+        if (schemaResult.success && schemaResult.data) {
+            log('Transforming custom operations...');
+            // Transform to CleanOperation[]
+            const { queries: allQueries, mutations: allMutations, typeRegistry } = (0, transform_schema_1.transformSchemaToOperations)(schemaResult.data);
+            log(`  Found ${allQueries.length} queries and ${allMutations.length} mutations total`);
+            // Filter by config include/exclude
+            const filteredQueries = (0, transform_schema_1.filterOperations)(allQueries, config.queries.include, config.queries.exclude);
+            const filteredMutations = (0, transform_schema_1.filterOperations)(allMutations, config.mutations.include, config.mutations.exclude);
+            log(`  After config filtering: ${filteredQueries.length} queries, ${filteredMutations.length} mutations`);
+            // Remove table operations (already handled by table generators)
+            const customQueriesOps = (0, transform_schema_1.getCustomOperations)(filteredQueries, tableOperationNames);
+            const customMutationsOps = (0, transform_schema_1.getCustomOperations)(filteredMutations, tableOperationNames);
+            log(`  Custom operations: ${customQueriesOps.length} queries, ${customMutationsOps.length} mutations`);
+            customQueries = customQueriesOps.map((q) => q.name);
+            customMutations = customMutationsOps.map((m) => m.name);
+            customOperationsData = {
+                queries: customQueriesOps,
+                mutations: customMutationsOps,
+                typeRegistry,
+            };
+        }
+        else {
+            log(`  Warning: Could not fetch __schema: ${schemaResult.error}`);
+            log('  Continuing with table-only generation...');
+        }
+    }
+    // 7. Generate code
+    log('Generating code...');
+    const { files: generatedFiles, stats } = (0, codegen_1.generate)({
+        tables,
+        customOperations: customOperationsData,
+        config,
+    });
+    log(`  Generated ${stats.queryHooks} table query hooks`);
+    log(`  Generated ${stats.mutationHooks} table mutation hooks`);
+    log(`  Generated ${stats.customQueryHooks} custom query hooks`);
+    log(`  Generated ${stats.customMutationHooks} custom mutation hooks`);
+    log(`  Total files: ${stats.totalFiles}`);
+    if (options.dryRun) {
+        return {
+            success: true,
+            message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${customQueries.length + customMutations.length} custom operations.`,
+            tables: tables.map((t) => t.name),
+            customQueries,
+            customMutations,
+            filesWritten: generatedFiles.map((f) => f.path),
+        };
+    }
+    // 8. Write files
+    log('Writing files...');
+    const writeResult = await writeGeneratedFiles(generatedFiles, config.output, ['queries', 'mutations']);
+    if (!writeResult.success) {
+        return {
+            success: false,
+            message: `Failed to write files: ${writeResult.errors?.join(', ')}`,
+            errors: writeResult.errors,
+        };
+    }
+    const totalOps = customQueries.length + customMutations.length;
+    const customOpsMsg = totalOps > 0 ? ` and ${totalOps} custom operations` : '';
+    return {
+        success: true,
+        message: `Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`,
+        tables: tables.map((t) => t.name),
+        customQueries,
+        customMutations,
+        filesWritten: writeResult.filesWritten,
+    };
+}
+async function loadConfig(options) {
+    // Find config file
+    let configPath = options.config;
+    if (!configPath) {
+        configPath = (0, init_1.findConfigFile)() ?? undefined;
+    }
+    let baseConfig = {};
+    if (configPath) {
+        const loadResult = await (0, init_1.loadConfigFile)(configPath);
+        if (!loadResult.success) {
+            return { success: false, error: loadResult.error };
+        }
+        baseConfig = loadResult.config;
+    }
+    // Override with CLI options
+    const mergedConfig = {
+        endpoint: options.endpoint || baseConfig.endpoint || '',
+        output: options.output || baseConfig.output,
+        headers: baseConfig.headers,
+        tables: baseConfig.tables,
+        queries: baseConfig.queries,
+        mutations: baseConfig.mutations,
+        excludeFields: baseConfig.excludeFields,
+        hooks: baseConfig.hooks,
+        postgraphile: baseConfig.postgraphile,
+        codegen: baseConfig.codegen,
+    };
+    if (!mergedConfig.endpoint) {
+        return {
+            success: false,
+            error: 'No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".',
+        };
+    }
+    // Resolve with defaults
+    const config = (0, config_1.resolveConfig)(mergedConfig);
+    return { success: true, config };
+}
+async function writeGeneratedFiles(files, outputDir, subdirs) {
+    const errors = [];
+    const written = [];
+    // Ensure output directory exists
+    try {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        return {
+            success: false,
+            errors: [`Failed to create output directory: ${message}`],
+        };
+    }
+    // Create subdirectories
+    for (const subdir of subdirs) {
+        const subdirPath = path.join(outputDir, subdir);
+        try {
+            fs.mkdirSync(subdirPath, { recursive: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            errors.push(`Failed to create directory ${subdirPath}: ${message}`);
+        }
+    }
+    if (errors.length > 0) {
+        return { success: false, errors };
+    }
+    for (const file of files) {
+        const filePath = path.join(outputDir, file.path);
+        // Ensure parent directory exists
+        const parentDir = path.dirname(filePath);
+        try {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        catch {
+            // Ignore if already exists
+        }
+        try {
+            // Format with prettier
+            const formattedContent = await formatCode(file.content);
+            fs.writeFileSync(filePath, formattedContent, 'utf-8');
+            written.push(filePath);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            errors.push(`Failed to write ${filePath}: ${message}`);
+        }
+    }
+    return {
+        success: errors.length === 0,
+        filesWritten: written,
+        errors: errors.length > 0 ? errors : undefined,
+    };
+}
+async function formatCode(code) {
+    try {
+        return await prettier.format(code, {
+            parser: 'typescript',
+            singleQuote: true,
+            trailingComma: 'es5',
+            tabWidth: 2,
+        });
+    }
+    catch {
+        // If prettier fails, return unformatted code
+        return code;
+    }
+}

package/cli/commands/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * CLI commands exports
+ */
+export { initCommand, findConfigFile, loadConfigFile } from './init';
+export type { InitOptions, InitResult } from './init';
+export { generateCommand } from './generate';
+export type { GenerateOptions, GenerateResult } from './generate';

package/cli/commands/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * CLI commands exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = exports.loadConfigFile = exports.findConfigFile = exports.initCommand = void 0;
+var init_1 = require("./init");
+Object.defineProperty(exports, "initCommand", { enumerable: true, get: function () { return init_1.initCommand; } });
+Object.defineProperty(exports, "findConfigFile", { enumerable: true, get: function () { return init_1.findConfigFile; } });
+Object.defineProperty(exports, "loadConfigFile", { enumerable: true, get: function () { return init_1.loadConfigFile; } });
+var generate_1 = require("./generate");
+Object.defineProperty(exports, "generateCommand", { enumerable: true, get: function () { return generate_1.generateCommand; } });

package/cli/commands/init.d.ts

@@ -0,0 +1,35 @@
+export interface InitOptions {
+    /** Target directory for the config file */
+    directory?: string;
+    /** Force overwrite existing config */
+    force?: boolean;
+    /** GraphQL endpoint URL to pre-populate */
+    endpoint?: string;
+    /** Output directory to pre-populate */
+    output?: string;
+}
+export interface InitResult {
+    success: boolean;
+    message: string;
+    configPath?: string;
+}
+/**
+ * Execute the init command
+ */
+export declare function initCommand(options?: InitOptions): Promise<InitResult>;
+/**
+ * Find the nearest config file by walking up directories
+ */
+export declare function findConfigFile(startDir?: string): string | null;
+/**
+ * Load and validate a config file
+ *
+ * Uses jiti to support TypeScript config files (.ts) in addition to
+ * JavaScript (.js, .mjs, .cjs) without requiring the user to have
+ * tsx or ts-node installed.
+ */
+export declare function loadConfigFile(configPath: string): Promise<{
+    success: boolean;
+    config?: any;
+    error?: string;
+}>;