@constructive-io/graphql-codegen 2.31.0 → 3.0.0

package/esm/cli/commands/generate-orm.js

@@ -1,289 +0,0 @@
-/**
- * Generate ORM command - generates Prisma-like ORM client from GraphQL schema
- *
- * This command:
- * 1. Fetches schema from endpoint or loads from file
- * 2. Infers table metadata from introspection (replaces _meta)
- * 3. Generates a Prisma-like ORM client with fluent API
- */
-import { isMultiConfig, mergeConfig, resolveConfig } from '../../types/config';
-import { createSchemaSource, validateSourceOptions, } from '../introspect/source';
-import { runCodegenPipeline, validateTablesFound } from './shared';
-import { findConfigFile, loadConfigFile } from './init';
-import { writeGeneratedFiles } from './generate';
-import { generateOrm } from '../codegen/orm';
-/**
- * Execute the generate-orm command
- */
-export async function generateOrmCommand(options = {}) {
-    if (options.verbose) {
-        console.log('Loading configuration...');
-    }
-    const configResult = await loadConfig(options);
-    if (!configResult.success) {
-        return {
-            success: false,
-            message: configResult.error,
-        };
-    }
-    const targets = configResult.targets ?? [];
-    if (targets.length === 0) {
-        return {
-            success: false,
-            message: 'No targets resolved from configuration.',
-        };
-    }
-    const isMultiTarget = configResult.isMulti ?? targets.length > 1;
-    const results = [];
-    for (const target of targets) {
-        const result = await generateOrmForTarget(target, options, isMultiTarget);
-        results.push(result);
-    }
-    if (!isMultiTarget) {
-        const [result] = results;
-        return {
-            success: result.success,
-            message: result.message,
-            targets: results,
-            tables: result.tables,
-            customQueries: result.customQueries,
-            customMutations: result.customMutations,
-            filesWritten: result.filesWritten,
-            errors: result.errors,
-        };
-    }
-    const successCount = results.filter((result) => result.success).length;
-    const failedCount = results.length - successCount;
-    const summaryMessage = failedCount === 0
-        ? `Generated ORM clients for ${results.length} targets.`
-        : `Generated ORM clients for ${successCount} of ${results.length} targets.`;
-    return {
-        success: failedCount === 0,
-        message: summaryMessage,
-        targets: results,
-        errors: failedCount > 0
-            ? results.flatMap((result) => result.errors ?? [])
-            : undefined,
-    };
-}
-async function generateOrmForTarget(target, options, isMultiTarget) {
-    const config = target.config;
-    const outputDir = options.output || config.orm?.output || './generated/orm';
-    const prefix = isMultiTarget ? `[${target.name}] ` : '';
-    const log = options.verbose
-        ? (message) => console.log(`${prefix}${message}`)
-        : () => { };
-    const formatMessage = (message) => isMultiTarget ? `Target "${target.name}": ${message}` : message;
-    if (isMultiTarget) {
-        console.log(`\nTarget "${target.name}"`);
-        const sourceLabel = config.schema
-            ? `schema: ${config.schema}`
-            : `endpoint: ${config.endpoint}`;
-        console.log(`  Source: ${sourceLabel}`);
-        console.log(`  Output: ${outputDir}`);
-    }
-    // 1. Validate source
-    const sourceValidation = validateSourceOptions({
-        endpoint: config.endpoint || undefined,
-        schema: config.schema || undefined,
-    });
-    if (!sourceValidation.valid) {
-        return {
-            name: target.name,
-            output: outputDir,
-            success: false,
-            message: formatMessage(sourceValidation.error),
-        };
-    }
-    const source = createSchemaSource({
-        endpoint: config.endpoint || undefined,
-        schema: config.schema || undefined,
-        authorization: options.authorization || config.headers['Authorization'],
-        headers: config.headers,
-    });
-    // 2. Run the codegen pipeline
-    let pipelineResult;
-    try {
-        pipelineResult = await runCodegenPipeline({
-            source,
-            config,
-            verbose: options.verbose,
-            skipCustomOperations: options.skipCustomOperations,
-        });
-    }
-    catch (err) {
-        return {
-            name: target.name,
-            output: outputDir,
-            success: false,
-            message: formatMessage(`Failed to fetch schema: ${err instanceof Error ? err.message : 'Unknown error'}`),
-        };
-    }
-    const { tables, customOperations, stats } = pipelineResult;
-    // 3. Validate tables found
-    const tablesValidation = validateTablesFound(tables);
-    if (!tablesValidation.valid) {
-        return {
-            name: target.name,
-            output: outputDir,
-            success: false,
-            message: formatMessage(tablesValidation.error),
-        };
-    }
-    // 4. Generate ORM code
-    console.log(`${prefix}Generating code...`);
-    const { files: generatedFiles, stats: genStats } = generateOrm({
-        tables,
-        customOperations: {
-            queries: customOperations.queries,
-            mutations: customOperations.mutations,
-            typeRegistry: customOperations.typeRegistry,
-        },
-        config,
-    });
-    console.log(`${prefix}Generated ${genStats.totalFiles} files`);
-    log(`  ${genStats.tables} table models`);
-    log(`  ${genStats.customQueries} custom query operations`);
-    log(`  ${genStats.customMutations} custom mutation operations`);
-    const customQueries = customOperations.queries.map((q) => q.name);
-    const customMutations = customOperations.mutations.map((m) => m.name);
-    if (options.dryRun) {
-        return {
-            name: target.name,
-            output: outputDir,
-            success: true,
-            message: formatMessage(`Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${stats.customQueries + stats.customMutations} custom operations.`),
-            tables: tables.map((t) => t.name),
-            customQueries,
-            customMutations,
-            filesWritten: generatedFiles.map((f) => f.path),
-        };
-    }
-    // 5. Write files
-    log('Writing files...');
-    const writeResult = await writeGeneratedFiles(generatedFiles, outputDir, [
-        'models',
-        'query',
-        'mutation',
-    ]);
-    if (!writeResult.success) {
-        return {
-            name: target.name,
-            output: outputDir,
-            success: false,
-            message: formatMessage(`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 {
-        name: target.name,
-        output: outputDir,
-        success: true,
-        message: formatMessage(`Generated ORM client for ${tables.length} tables${customOpsMsg}. Files written to ${outputDir}`),
-        tables: tables.map((t) => t.name),
-        customQueries,
-        customMutations,
-        filesWritten: writeResult.filesWritten,
-    };
-}
-function buildTargetOverrides(options) {
-    const overrides = {};
-    if (options.endpoint) {
-        overrides.endpoint = options.endpoint;
-        overrides.schema = undefined;
-    }
-    if (options.schema) {
-        overrides.schema = options.schema;
-        overrides.endpoint = undefined;
-    }
-    return overrides;
-}
-async function loadConfig(options) {
-    if (options.endpoint && options.schema) {
-        return {
-            success: false,
-            error: 'Cannot use both --endpoint and --schema. Choose one source.',
-        };
-    }
-    // Find config file
-    let configPath = options.config;
-    if (!configPath) {
-        configPath = findConfigFile() ?? undefined;
-    }
-    let baseConfig = {};
-    if (configPath) {
-        const loadResult = await loadConfigFile(configPath);
-        if (!loadResult.success) {
-            return { success: false, error: loadResult.error };
-        }
-        baseConfig = loadResult.config;
-    }
-    const overrides = buildTargetOverrides(options);
-    if (isMultiConfig(baseConfig)) {
-        if (Object.keys(baseConfig.targets).length === 0) {
-            return {
-                success: false,
-                error: 'Config file defines no targets.',
-            };
-        }
-        if (!options.target &&
-            (options.endpoint || options.schema || options.output)) {
-            return {
-                success: false,
-                error: 'Multiple targets configured. Use --target with --endpoint, --schema, or --output.',
-            };
-        }
-        if (options.target && !baseConfig.targets[options.target]) {
-            return {
-                success: false,
-                error: `Target "${options.target}" not found in config file.`,
-            };
-        }
-        const selectedTargets = options.target
-            ? { [options.target]: baseConfig.targets[options.target] }
-            : baseConfig.targets;
-        const defaults = baseConfig.defaults ?? {};
-        const resolvedTargets = [];
-        for (const [name, target] of Object.entries(selectedTargets)) {
-            let mergedTarget = mergeConfig(defaults, target);
-            if (options.target && name === options.target) {
-                mergedTarget = mergeConfig(mergedTarget, overrides);
-            }
-            if (!mergedTarget.endpoint && !mergedTarget.schema) {
-                return {
-                    success: false,
-                    error: `Target "${name}" is missing an endpoint or schema.`,
-                };
-            }
-            resolvedTargets.push({
-                name,
-                config: resolveConfig(mergedTarget),
-            });
-        }
-        return {
-            success: true,
-            targets: resolvedTargets,
-            isMulti: true,
-        };
-    }
-    if (options.target) {
-        return {
-            success: false,
-            error: 'Config file does not define targets. Remove --target to continue.',
-        };
-    }
-    const mergedConfig = mergeConfig(baseConfig, overrides);
-    if (!mergedConfig.endpoint && !mergedConfig.schema) {
-        return {
-            success: false,
-            error: 'No source specified. Use --endpoint or --schema, or create a config file with "graphql-codegen init".',
-        };
-    }
-    return {
-        success: true,
-        targets: [{ name: 'default', config: resolveConfig(mergedConfig) }],
-        isMulti: false,
-    };
-}

package/esm/cli/commands/generate.d.ts

@@ -1,66 +0,0 @@
-export interface GenerateOptions {
-    /** Path to config file */
-    config?: string;
-    /** Named target in a multi-target config */
-    target?: string;
-    /** GraphQL endpoint URL (overrides config) */
-    endpoint?: string;
-    /** Path to GraphQL schema file (.graphql) */
-    schema?: 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 GenerateTargetResult {
-    name: string;
-    output: string;
-    success: boolean;
-    message: string;
-    tables?: string[];
-    customQueries?: string[];
-    customMutations?: string[];
-    filesWritten?: string[];
-    errors?: string[];
-}
-export interface GenerateResult {
-    success: boolean;
-    message: string;
-    targets?: GenerateTargetResult[];
-    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 interface WriteOptions {
-    showProgress?: boolean;
-}
-export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[], options?: WriteOptions): Promise<WriteResult>;
-/**
- * Format generated files using prettier
- * Runs prettier on the output directory after all files are written
- */
-export declare function formatOutput(outputDir: string): {
-    success: boolean;
-    error?: string;
-};