@constructive-io/graphql-codegen 2.31.0 → 3.0.0

package/esm/cli/commands/generate.js

@@ -1,393 +0,0 @@
-/**
- * Generate command - generates SDK from GraphQL schema
- *
- * This command:
- * 1. Fetches schema from endpoint or loads from file
- * 2. Infers table metadata from introspection (replaces _meta)
- * 3. Generates hooks for both table CRUD and custom operations
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { execSync } from 'node:child_process';
-import { isMultiConfig, mergeConfig, resolveConfig } from '../../types/config';
-import { createSchemaSource, validateSourceOptions, } from '../introspect/source';
-import { runCodegenPipeline, validateTablesFound } from './shared';
-import { findConfigFile, loadConfigFile } from './init';
-import { generate } from '../codegen';
-/**
- * Execute the generate command
- */
-export async function generateCommand(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 generateForTarget(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 SDK for ${results.length} targets.`
-        : `Generated SDK 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 generateForTarget(target, options, isMultiTarget) {
-    const config = target.config;
-    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: ${config.output}`);
-    }
-    // 1. Validate source
-    const sourceValidation = validateSourceOptions({
-        endpoint: config.endpoint || undefined,
-        schema: config.schema || undefined,
-    });
-    if (!sourceValidation.valid) {
-        return {
-            name: target.name,
-            output: config.output,
-            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: config.output,
-            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: config.output,
-            success: false,
-            message: formatMessage(tablesValidation.error),
-        };
-    }
-    // 4. Generate code
-    console.log(`${prefix}Generating code...`);
-    const { files: generatedFiles, stats: genStats } = generate({
-        tables,
-        customOperations: {
-            queries: customOperations.queries,
-            mutations: customOperations.mutations,
-            typeRegistry: customOperations.typeRegistry,
-        },
-        config,
-    });
-    console.log(`${prefix}Generated ${genStats.totalFiles} files`);
-    log(`  ${genStats.queryHooks} table query hooks`);
-    log(`  ${genStats.mutationHooks} table mutation hooks`);
-    log(`  ${genStats.customQueryHooks} custom query hooks`);
-    log(`  ${genStats.customMutationHooks} custom mutation hooks`);
-    const customQueries = customOperations.queries.map((q) => q.name);
-    const customMutations = customOperations.mutations.map((m) => m.name);
-    if (options.dryRun) {
-        return {
-            name: target.name,
-            output: config.output,
-            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, config.output, [
-        'queries',
-        'mutations',
-    ]);
-    if (!writeResult.success) {
-        return {
-            name: target.name,
-            output: config.output,
-            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: config.output,
-        success: true,
-        message: formatMessage(`Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`),
-        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;
-    }
-    if (options.output) {
-        overrides.output = options.output;
-    }
-    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,
-    };
-}
-export async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
-    const { showProgress = true } = options;
-    const errors = [];
-    const written = [];
-    const total = files.length;
-    const isTTY = process.stdout.isTTY;
-    // 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 (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        const filePath = path.join(outputDir, file.path);
-        // Show progress
-        if (showProgress) {
-            const progress = Math.round(((i + 1) / total) * 100);
-            if (isTTY) {
-                process.stdout.write(`\rWriting files: ${i + 1}/${total} (${progress}%)`);
-            }
-            else if (i % 100 === 0 || i === total - 1) {
-                // Non-TTY: periodic updates for CI/CD
-                console.log(`Writing files: ${i + 1}/${total}`);
-            }
-        }
-        // Ensure parent directory exists
-        const parentDir = path.dirname(filePath);
-        try {
-            fs.mkdirSync(parentDir, { recursive: true });
-        }
-        catch {
-            // Ignore if already exists
-        }
-        try {
-            fs.writeFileSync(filePath, file.content, 'utf-8');
-            written.push(filePath);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            errors.push(`Failed to write ${filePath}: ${message}`);
-        }
-    }
-    // Clear progress line
-    if (showProgress && isTTY) {
-        process.stdout.write('\r' + ' '.repeat(40) + '\r');
-    }
-    // Format all generated files with prettier
-    if (errors.length === 0) {
-        if (showProgress) {
-            console.log('Formatting generated files...');
-        }
-        const formatResult = formatOutput(outputDir);
-        if (!formatResult.success && showProgress) {
-            console.warn('Warning: Failed to format generated files:', formatResult.error);
-        }
-    }
-    return {
-        success: errors.length === 0,
-        filesWritten: written,
-        errors: errors.length > 0 ? errors : undefined,
-    };
-}
-/**
- * Format generated files using prettier
- * Runs prettier on the output directory after all files are written
- */
-export function formatOutput(outputDir) {
-    const absoluteOutputDir = path.resolve(outputDir);
-    try {
-        execSync(`npx prettier --write --single-quote --trailing-comma all --tab-width 2 --semi "${absoluteOutputDir}"`, {
-            stdio: 'pipe',
-            encoding: 'utf-8',
-        });
-        return { success: true };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return { success: false, error: message };
-    }
-}

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

@@ -1,9 +0,0 @@
-/**
- * CLI commands exports
- */
-export { initCommand, findConfigFile, loadConfigFile } from './init';
-export type { InitOptions, InitResult } from './init';
-export { generateCommand } from './generate';
-export type { GenerateOptions, GenerateResult, GenerateTargetResult } from './generate';
-export { generateOrmCommand } from './generate-orm';
-export type { GenerateOrmOptions, GenerateOrmResult, GenerateOrmTargetResult } from './generate-orm';

package/esm/cli/commands/index.js

@@ -1,6 +0,0 @@
-/**
- * CLI commands exports
- */
-export { initCommand, findConfigFile, loadConfigFile } from './init';
-export { generateCommand } from './generate';
-export { generateOrmCommand } from './generate-orm';

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

@@ -1,35 +0,0 @@
-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;
-}>;

package/esm/cli/commands/init.js

@@ -1,158 +0,0 @@
-/**
- * Init command - creates a new graphql-codegen configuration file
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { createJiti } from 'jiti';
-const CONFIG_FILENAME = 'graphql-codegen.config.ts';
-const CONFIG_TEMPLATE = `import { defineConfig } from '@constructive-io/graphql-codegen';
-
-export default defineConfig({
-  // GraphQL endpoint URL (PostGraphile with _meta plugin)
-  endpoint: '{{ENDPOINT}}',
-
-  // Output directory for generated files
-  output: '{{OUTPUT}}',
-
-  // Optional: Multi-target config (use instead of endpoint/output)
-  // defaults: {
-  //   headers: { Authorization: 'Bearer YOUR_TOKEN' },
-  // },
-  // targets: {
-  //   public: { endpoint: 'https://api.example.com/graphql', output: './generated/public' },
-  //   admin: { schema: './admin.schema.graphql', output: './generated/admin' },
-  // },
-
-  // Optional: Tables to include/exclude (supports glob patterns)
-  // tables: {
-  //   include: ['*'],
-  //   exclude: ['_*', 'pg_*'],
-  // },
-
-  // Optional: Authorization header for authenticated endpoints
-  // headers: {
-  //   Authorization: 'Bearer YOUR_TOKEN',
-  // },
-
-  // Optional: Watch mode settings (in-memory caching, no file I/O)
-  // watch: {
-  //   pollInterval: 3000,  // ms
-  //   debounce: 800,       // ms
-  //   clearScreen: true,
-  //   touchFile: '.trigger',  // Optional: file to touch on change
-  // },
-});
-`;
-/**
- * Execute the init command
- */
-export async function initCommand(options = {}) {
-    const { directory = process.cwd(), force = false, endpoint = '', output = './generated', } = options;
-    const configPath = path.join(directory, CONFIG_FILENAME);
-    // Check if config already exists
-    if (fs.existsSync(configPath) && !force) {
-        return {
-            success: false,
-            message: `Configuration file already exists: ${configPath}\nUse --force to overwrite.`,
-        };
-    }
-    // Generate config content
-    const content = CONFIG_TEMPLATE.replace('{{ENDPOINT}}', endpoint || 'http://localhost:5000/graphql').replace('{{OUTPUT}}', output);
-    try {
-        // Ensure directory exists
-        fs.mkdirSync(directory, { recursive: true });
-        // Write config file
-        fs.writeFileSync(configPath, content, 'utf-8');
-        return {
-            success: true,
-            message: `Created configuration file: ${configPath}`,
-            configPath,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown error';
-        return {
-            success: false,
-            message: `Failed to create configuration file: ${message}`,
-        };
-    }
-}
-/**
- * Find the nearest config file by walking up directories
- */
-export function findConfigFile(startDir = process.cwd()) {
-    let currentDir = startDir;
-    while (true) {
-        const configPath = path.join(currentDir, CONFIG_FILENAME);
-        if (fs.existsSync(configPath)) {
-            return configPath;
-        }
-        const parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) {
-            // Reached root
-            return null;
-        }
-        currentDir = parentDir;
-    }
-}
-/**
- * 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 async function loadConfigFile(configPath) {
-    const resolvedPath = path.resolve(configPath);
-    if (!fs.existsSync(resolvedPath)) {
-        return {
-            success: false,
-            error: `Config file not found: ${resolvedPath}`,
-        };
-    }
-    try {
-        // Use jiti to load TypeScript/ESM config files seamlessly
-        // jiti handles .ts, .js, .mjs, .cjs and ESM/CJS interop
-        const jiti = createJiti(__filename, {
-            interopDefault: true,
-            debug: process.env.JITI_DEBUG === '1',
-        });
-        // jiti.import() with { default: true } returns mod?.default ?? mod
-        const config = await jiti.import(resolvedPath, { default: true });
-        if (!config || typeof config !== 'object') {
-            return {
-                success: false,
-                error: 'Config file must export a configuration object',
-            };
-        }
-        const hasEndpoint = 'endpoint' in config;
-        const hasSchema = 'schema' in config;
-        const hasTargets = 'targets' in config;
-        if (!hasEndpoint && !hasSchema && !hasTargets) {
-            return {
-                success: false,
-                error: 'Config file must define "endpoint", "schema", or "targets".',
-            };
-        }
-        if (hasTargets) {
-            const targets = config.targets;
-            if (!targets || typeof targets !== 'object' || Array.isArray(targets)) {
-                return {
-                    success: false,
-                    error: 'Config file "targets" must be an object of named configs.',
-                };
-            }
-        }
-        return {
-            success: true,
-            config,
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : 'Unknown error';
-        return {
-            success: false,
-            error: `Failed to load config file: ${message}`,
-        };
-    }
-}

package/esm/cli/introspect/source/index.d.ts

@@ -1,48 +0,0 @@
-/**
- * Schema Source Module
- *
- * Provides a unified interface for loading GraphQL schemas from different sources:
- * - Live GraphQL endpoints (via introspection)
- * - Static .graphql schema files
- */
-export * from './types';
-export * from './endpoint';
-export * from './file';
-import type { SchemaSource } from './types';
-export interface CreateSchemaSourceOptions {
-    /**
-     * GraphQL endpoint URL (for live introspection)
-     */
-    endpoint?: string;
-    /**
-     * Path to GraphQL schema file (.graphql)
-     */
-    schema?: string;
-    /**
-     * Optional authorization header for endpoint requests
-     */
-    authorization?: string;
-    /**
-     * Optional additional headers for endpoint requests
-     */
-    headers?: Record<string, string>;
-    /**
-     * Request timeout in milliseconds (for endpoint requests)
-     */
-    timeout?: number;
-}
-/**
- * Create a schema source based on configuration
- *
- * @param options - Source configuration
- * @returns Appropriate SchemaSource implementation
- * @throws Error if neither endpoint nor schema is provided
- */
-export declare function createSchemaSource(options: CreateSchemaSourceOptions): SchemaSource;
-/**
- * Validate that source options are valid (at least one source specified)
- */
-export declare function validateSourceOptions(options: CreateSchemaSourceOptions): {
-    valid: boolean;
-    error?: string;
-};