@constructive-io/graphql-codegen 2.32.0 → 3.0.1

package/cli/commands/generate.js

@@ -1,431 +0,0 @@
-"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.generateReactQuery = generateReactQuery;
-exports.writeGeneratedFiles = writeGeneratedFiles;
-exports.formatOutput = formatOutput;
-/**
- * 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
- */
-const fs = __importStar(require("node:fs"));
-const path = __importStar(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-const config_1 = require("../../types/config");
-const source_1 = require("../introspect/source");
-const shared_1 = require("./shared");
-const init_1 = require("./init");
-const codegen_1 = require("../codegen");
-/**
- * Execute the generate command (generates React Query SDK)
- */
-async function generateReactQuery(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 = (0, source_1.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 = (0, source_1.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 (0, shared_1.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 = (0, shared_1.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 } = (0, codegen_1.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 = (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;
-    }
-    const overrides = buildTargetOverrides(options);
-    if ((0, config_1.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 = (0, config_1.mergeConfig)(defaults, target);
-            if (options.target && name === options.target) {
-                mergedTarget = (0, config_1.mergeConfig)(mergedTarget, overrides);
-            }
-            if (!mergedTarget.endpoint && !mergedTarget.schema) {
-                return {
-                    success: false,
-                    error: `Target "${name}" is missing an endpoint or schema.`,
-                };
-            }
-            resolvedTargets.push({
-                name,
-                config: (0, config_1.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 = (0, config_1.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: (0, config_1.resolveConfig)(mergedConfig) }],
-        isMulti: false,
-    };
-}
-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
- */
-function formatOutput(outputDir) {
-    const absoluteOutputDir = path.resolve(outputDir);
-    try {
-        (0, node_child_process_1.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/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 { generateReactQuery } from './generate';
-export type { GenerateOptions, GenerateResult, GenerateTargetResult } from './generate';
-export { generateOrm } from './generate-orm';
-export type { GenerateOrmOptions, GenerateOrmResult, GenerateOrmTargetResult } from './generate-orm';

package/cli/commands/index.js

@@ -1,14 +0,0 @@
-"use strict";
-/**
- * CLI commands exports
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateOrm = exports.generateReactQuery = 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, "generateReactQuery", { enumerable: true, get: function () { return generate_1.generateReactQuery; } });
-var generate_orm_1 = require("./generate-orm");
-Object.defineProperty(exports, "generateOrm", { enumerable: true, get: function () { return generate_orm_1.generateOrm; } });

package/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/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;
-};

package/cli/introspect/source/index.js

@@ -1,72 +0,0 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSchemaSource = createSchemaSource;
-exports.validateSourceOptions = validateSourceOptions;
-/**
- * Schema Source Module
- *
- * Provides a unified interface for loading GraphQL schemas from different sources:
- * - Live GraphQL endpoints (via introspection)
- * - Static .graphql schema files
- */
-__exportStar(require("./types"), exports);
-__exportStar(require("./endpoint"), exports);
-__exportStar(require("./file"), exports);
-const endpoint_1 = require("./endpoint");
-const file_1 = require("./file");
-/**
- * Create a schema source based on configuration
- *
- * @param options - Source configuration
- * @returns Appropriate SchemaSource implementation
- * @throws Error if neither endpoint nor schema is provided
- */
-function createSchemaSource(options) {
-    if (options.schema) {
-        return new file_1.FileSchemaSource({
-            schemaPath: options.schema,
-        });
-    }
-    if (options.endpoint) {
-        return new endpoint_1.EndpointSchemaSource({
-            endpoint: options.endpoint,
-            authorization: options.authorization,
-            headers: options.headers,
-            timeout: options.timeout,
-        });
-    }
-    throw new Error('Either endpoint or schema must be provided. ' +
-        'Use --endpoint for live introspection or --schema for a local file.');
-}
-/**
- * Validate that source options are valid (at least one source specified)
- */
-function validateSourceOptions(options) {
-    if (!options.endpoint && !options.schema) {
-        return {
-            valid: false,
-            error: 'Either endpoint or schema must be provided',
-        };
-    }
-    if (options.endpoint && options.schema) {
-        return {
-            valid: false,
-            error: 'Cannot use both endpoint and schema. Choose one source.',
-        };
-    }
-    return { valid: true };
-}

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

@@ -1,53 +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
- */
-export interface GenerateOrmOptions {
-    /** 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 GenerateOrmTargetResult {
-    name: string;
-    output: string;
-    success: boolean;
-    message: string;
-    tables?: string[];
-    customQueries?: string[];
-    customMutations?: string[];
-    filesWritten?: string[];
-    errors?: string[];
-}
-export interface GenerateOrmResult {
-    success: boolean;
-    message: string;
-    targets?: GenerateOrmTargetResult[];
-    tables?: string[];
-    customQueries?: string[];
-    customMutations?: string[];
-    filesWritten?: string[];
-    errors?: string[];
-}
-/**
- * Execute the generate-orm command (generates ORM client)
- */
-export declare function generateOrm(options?: GenerateOrmOptions): Promise<GenerateOrmResult>;