@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/cli/commands/init.js

@@ -0,0 +1,176 @@
+"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.initCommand = initCommand;
+exports.findConfigFile = findConfigFile;
+exports.loadConfigFile = loadConfigFile;
+/**
+ * Init command - creates a new graphql-codegen configuration file
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const jiti_1 = require("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: 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
+ */
+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
+ */
+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.
+ */
+async function loadConfigFile(configPath) {
+    if (!fs.existsSync(configPath)) {
+        return {
+            success: false,
+            error: `Config file not found: ${configPath}`,
+        };
+    }
+    try {
+        // Use jiti to load TypeScript/ESM config files seamlessly
+        // jiti handles .ts, .js, .mjs, .cjs and ESM/CJS interop
+        const jiti = (0, jiti_1.createJiti)(__filename, {
+            interopDefault: true,
+            debug: process.env.JITI_DEBUG === '1',
+        });
+        // jiti.import() with { default: true } returns mod?.default ?? mod
+        const config = await jiti.import(configPath, { default: true });
+        if (!config || typeof config !== 'object') {
+            return {
+                success: false,
+                error: 'Config file must export a configuration object',
+            };
+        }
+        if (!('endpoint' in config)) {
+            return {
+                success: false,
+                error: 'Config file missing required "endpoint" property',
+            };
+        }
+        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/cli/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * CLI entry point for graphql-codegen
+ */
+export {};

package/cli/index.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * CLI entry point for graphql-codegen
+ */
+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 });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const generate_1 = require("./commands/generate");
+const generate_orm_1 = require("./commands/generate-orm");
+const watch_1 = require("./watch");
+const config_1 = require("../types/config");
+const program = new commander_1.Command();
+/**
+ * Load configuration for watch mode, merging CLI options with config file
+ */
+async function loadWatchConfig(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) {
+            console.error('✗', loadResult.error);
+            return null;
+        }
+        baseConfig = loadResult.config;
+    }
+    // Merge CLI options with config
+    const mergedConfig = {
+        endpoint: options.endpoint || baseConfig.endpoint || '',
+        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,
+        watch: {
+            ...baseConfig.watch,
+            // CLI options override config
+            ...(options.pollInterval !== undefined && { pollInterval: options.pollInterval }),
+            ...(options.debounce !== undefined && { debounce: options.debounce }),
+            ...(options.touch !== undefined && { touchFile: options.touch }),
+            ...(options.clear !== undefined && { clearScreen: options.clear }),
+        },
+    };
+    if (!mergedConfig.endpoint) {
+        console.error('✗ No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".');
+        return null;
+    }
+    return (0, config_1.resolveConfig)(mergedConfig);
+}
+program
+    .name('graphql-codegen')
+    .description('CLI for generating GraphQL SDK from PostGraphile endpoints')
+    .version('2.17.48');
+// Init command
+program
+    .command('init')
+    .description('Initialize a new graphql-codegen configuration file')
+    .option('-d, --directory <dir>', 'Target directory for the config file', '.')
+    .option('-f, --force', 'Force overwrite existing config', false)
+    .option('-e, --endpoint <url>', 'GraphQL endpoint URL to pre-populate')
+    .option('-o, --output <dir>', 'Output directory to pre-populate', './generated')
+    .action(async (options) => {
+    const result = await (0, init_1.initCommand)({
+        directory: options.directory,
+        force: options.force,
+        endpoint: options.endpoint,
+        output: options.output,
+    });
+    if (result.success) {
+        console.log('✓', result.message);
+    }
+    else {
+        console.error('✗', result.message);
+        process.exit(1);
+    }
+});
+// Generate command
+program
+    .command('generate')
+    .description('Generate SDK from GraphQL endpoint')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-e, --endpoint <url>', 'GraphQL endpoint URL (overrides config)')
+    .option('-o, --output <dir>', 'Output directory (overrides config)')
+    .option('-a, --authorization <header>', 'Authorization header value')
+    .option('-v, --verbose', 'Verbose output', false)
+    .option('--dry-run', 'Dry run - show what would be generated without writing files', false)
+    .option('-w, --watch', 'Watch mode - poll endpoint for schema changes (in-memory)', false)
+    .option('--poll-interval <ms>', 'Polling interval in milliseconds (default: 3000)', parseInt)
+    .option('--debounce <ms>', 'Debounce delay before regenerating (default: 800)', parseInt)
+    .option('--touch <file>', 'File to touch on schema change')
+    .option('--no-clear', 'Do not clear terminal on regeneration')
+    .action(async (options) => {
+    // Watch mode
+    if (options.watch) {
+        const config = await loadWatchConfig(options);
+        if (!config) {
+            process.exit(1);
+        }
+        await (0, watch_1.startWatch)({
+            config,
+            generatorType: 'generate',
+            verbose: options.verbose,
+            authorization: options.authorization,
+            outputDir: options.output,
+        });
+        return;
+    }
+    // Normal one-shot generation
+    const result = await (0, generate_1.generateCommand)({
+        config: options.config,
+        endpoint: options.endpoint,
+        output: options.output,
+        authorization: options.authorization,
+        verbose: options.verbose,
+        dryRun: options.dryRun,
+    });
+    if (result.success) {
+        console.log('✓', result.message);
+        if (result.tables && result.tables.length > 0) {
+            console.log('\nTables:');
+            result.tables.forEach((t) => console.log(`  - ${t}`));
+        }
+        if (result.filesWritten && result.filesWritten.length > 0) {
+            console.log('\nFiles written:');
+            result.filesWritten.forEach((f) => console.log(`  - ${f}`));
+        }
+    }
+    else {
+        console.error('✗', result.message);
+        if (result.errors) {
+            result.errors.forEach((e) => console.error('  -', e));
+        }
+        process.exit(1);
+    }
+});
+// Generate ORM command
+program
+    .command('generate-orm')
+    .description('Generate Prisma-like ORM client from GraphQL endpoint')
+    .option('-c, --config <path>', 'Path to config file')
+    .option('-e, --endpoint <url>', 'GraphQL endpoint URL (overrides config)')
+    .option('-o, --output <dir>', 'Output directory (overrides config)', './generated/orm')
+    .option('-a, --authorization <header>', 'Authorization header value')
+    .option('-v, --verbose', 'Verbose output', false)
+    .option('--dry-run', 'Dry run - show what would be generated without writing files', false)
+    .option('--skip-custom-operations', 'Skip custom operations (only generate table CRUD)', false)
+    .option('-w, --watch', 'Watch mode - poll endpoint for schema changes (in-memory)', false)
+    .option('--poll-interval <ms>', 'Polling interval in milliseconds (default: 3000)', parseInt)
+    .option('--debounce <ms>', 'Debounce delay before regenerating (default: 800)', parseInt)
+    .option('--touch <file>', 'File to touch on schema change')
+    .option('--no-clear', 'Do not clear terminal on regeneration')
+    .action(async (options) => {
+    // Watch mode
+    if (options.watch) {
+        const config = await loadWatchConfig(options);
+        if (!config) {
+            process.exit(1);
+        }
+        await (0, watch_1.startWatch)({
+            config,
+            generatorType: 'generate-orm',
+            verbose: options.verbose,
+            authorization: options.authorization,
+            outputDir: options.output,
+            skipCustomOperations: options.skipCustomOperations,
+        });
+        return;
+    }
+    // Normal one-shot generation
+    const result = await (0, generate_orm_1.generateOrmCommand)({
+        config: options.config,
+        endpoint: options.endpoint,
+        output: options.output,
+        authorization: options.authorization,
+        verbose: options.verbose,
+        dryRun: options.dryRun,
+        skipCustomOperations: options.skipCustomOperations,
+    });
+    if (result.success) {
+        console.log('✓', result.message);
+        if (result.tables && result.tables.length > 0) {
+            console.log('\nTables:');
+            result.tables.forEach((t) => console.log(`  - ${t}`));
+        }
+        if (result.customQueries && result.customQueries.length > 0) {
+            console.log('\nCustom Queries:');
+            result.customQueries.forEach((q) => console.log(`  - ${q}`));
+        }
+        if (result.customMutations && result.customMutations.length > 0) {
+            console.log('\nCustom Mutations:');
+            result.customMutations.forEach((m) => console.log(`  - ${m}`));
+        }
+        if (result.filesWritten && result.filesWritten.length > 0) {
+            console.log('\nFiles written:');
+            result.filesWritten.forEach((f) => console.log(`  - ${f}`));
+        }
+    }
+    else {
+        console.error('✗', result.message);
+        if (result.errors) {
+            result.errors.forEach((e) => console.error('  -', e));
+        }
+        process.exit(1);
+    }
+});
+// Introspect command (for debugging)
+program
+    .command('introspect')
+    .description('Introspect a GraphQL endpoint and print table info')
+    .requiredOption('-e, --endpoint <url>', 'GraphQL endpoint URL')
+    .option('-a, --authorization <header>', 'Authorization header value')
+    .option('--json', 'Output as JSON', false)
+    .action(async (options) => {
+    const { fetchMeta, validateEndpoint } = await Promise.resolve().then(() => __importStar(require('./introspect/fetch-meta')));
+    const { transformMetaToCleanTables, getTableNames } = await Promise.resolve().then(() => __importStar(require('./introspect/transform')));
+    // Validate endpoint
+    const validation = validateEndpoint(options.endpoint);
+    if (!validation.valid) {
+        console.error('✗ Invalid endpoint:', validation.error);
+        process.exit(1);
+    }
+    console.log('Fetching schema from', options.endpoint, '...');
+    const result = await fetchMeta({
+        endpoint: options.endpoint,
+        authorization: options.authorization,
+    });
+    if (!result.success) {
+        console.error('✗ Failed to fetch schema:', result.error);
+        process.exit(1);
+    }
+    const tables = transformMetaToCleanTables(result.data);
+    const tableNames = getTableNames(tables);
+    if (options.json) {
+        console.log(JSON.stringify(tables, null, 2));
+    }
+    else {
+        console.log(`\n✓ Found ${tables.length} tables:\n`);
+        tableNames.forEach((name) => {
+            const table = tables.find((t) => t.name === name);
+            const fieldCount = table.fields.length;
+            const relationCount = table.relations.belongsTo.length +
+                table.relations.hasOne.length +
+                table.relations.hasMany.length +
+                table.relations.manyToMany.length;
+            console.log(`  ${name} (${fieldCount} fields, ${relationCount} relations)`);
+        });
+    }
+});
+program.parse();

package/cli/introspect/fetch-meta.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fetch _meta query from a PostGraphile endpoint
+ */
+import { type MetaQueryResponse } from './meta-query';
+export interface FetchMetaOptions {
+    /** GraphQL endpoint URL */
+    endpoint: string;
+    /** Optional authorization header value (e.g., "Bearer token") */
+    authorization?: string;
+    /** Optional additional headers */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+export interface FetchMetaResult {
+    success: boolean;
+    data?: MetaQueryResponse;
+    error?: string;
+    statusCode?: number;
+}
+/**
+ * Fetch the _meta query from a PostGraphile endpoint
+ */
+export declare function fetchMeta(options: FetchMetaOptions): Promise<FetchMetaResult>;
+/**
+ * Validate that an endpoint URL is valid
+ */
+export declare function validateEndpoint(endpoint: string): {
+    valid: boolean;
+    error?: string;
+};

package/cli/introspect/fetch-meta.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchMeta = fetchMeta;
+exports.validateEndpoint = validateEndpoint;
+/**
+ * Fetch _meta query from a PostGraphile endpoint
+ */
+const meta_query_1 = require("./meta-query");
+/**
+ * Fetch the _meta query from a PostGraphile endpoint
+ */
+async function fetchMeta(options) {
+    const { endpoint, authorization, headers = {}, timeout = 30000 } = options;
+    // Build headers
+    const requestHeaders = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        ...headers,
+    };
+    if (authorization) {
+        requestHeaders['Authorization'] = authorization;
+    }
+    // Create abort controller for timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: requestHeaders,
+            body: JSON.stringify({
+                query: meta_query_1.META_QUERY,
+                variables: {},
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return {
+                success: false,
+                error: `HTTP ${response.status}: ${response.statusText}`,
+                statusCode: response.status,
+            };
+        }
+        const json = (await response.json());
+        // Check for GraphQL errors
+        if (json.errors && json.errors.length > 0) {
+            const errorMessages = json.errors.map((e) => e.message).join('; ');
+            return {
+                success: false,
+                error: `GraphQL errors: ${errorMessages}`,
+                statusCode: response.status,
+            };
+        }
+        // Check if _meta is present
+        if (!json.data?._meta) {
+            return {
+                success: false,
+                error: 'No _meta field in response. Make sure the endpoint has the PostGraphile meta plugin installed.',
+                statusCode: response.status,
+            };
+        }
+        return {
+            success: true,
+            data: json.data,
+            statusCode: response.status,
+        };
+    }
+    catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof Error) {
+            if (err.name === 'AbortError') {
+                return {
+                    success: false,
+                    error: `Request timeout after ${timeout}ms`,
+                };
+            }
+            return {
+                success: false,
+                error: err.message,
+            };
+        }
+        return {
+            success: false,
+            error: 'Unknown error occurred',
+        };
+    }
+}
+/**
+ * Validate that an endpoint URL is valid
+ */
+function validateEndpoint(endpoint) {
+    try {
+        const url = new URL(endpoint);
+        if (!['http:', 'https:'].includes(url.protocol)) {
+            return {
+                valid: false,
+                error: 'Endpoint must use http or https protocol',
+            };
+        }
+        return { valid: true };
+    }
+    catch {
+        return {
+            valid: false,
+            error: 'Invalid URL format',
+        };
+    }
+}

package/cli/introspect/fetch-schema.d.ts

@@ -0,0 +1,21 @@
+import type { IntrospectionQueryResponse } from '../../types/introspection';
+export interface FetchSchemaOptions {
+    /** GraphQL endpoint URL */
+    endpoint: string;
+    /** Optional authorization header value (e.g., "Bearer token") */
+    authorization?: string;
+    /** Optional additional headers */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+export interface FetchSchemaResult {
+    success: boolean;
+    data?: IntrospectionQueryResponse;
+    error?: string;
+    statusCode?: number;
+}
+/**
+ * Fetch the full schema introspection from a GraphQL endpoint
+ */
+export declare function fetchSchema(options: FetchSchemaOptions): Promise<FetchSchemaResult>;