@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/esm/cli/index.js

@@ -0,0 +1,256 @@
+/**
+ * CLI entry point for graphql-codegen
+ */
+import { Command } from 'commander';
+import { initCommand, findConfigFile, loadConfigFile } from './commands/init';
+import { generateCommand } from './commands/generate';
+import { generateOrmCommand } from './commands/generate-orm';
+import { startWatch } from './watch';
+import { resolveConfig } from '../types/config';
+const program = new 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 = findConfigFile() ?? undefined;
+    }
+    let baseConfig = {};
+    if (configPath) {
+        const loadResult = await 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 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 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 startWatch({
+            config,
+            generatorType: 'generate',
+            verbose: options.verbose,
+            authorization: options.authorization,
+            outputDir: options.output,
+        });
+        return;
+    }
+    // Normal one-shot generation
+    const result = await 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 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 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 import('./introspect/fetch-meta');
+    const { transformMetaToCleanTables, getTableNames } = await import('./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/esm/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/esm/cli/introspect/fetch-meta.js

@@ -0,0 +1,104 @@
+/**
+ * Fetch _meta query from a PostGraphile endpoint
+ */
+import { META_QUERY } from './meta-query';
+/**
+ * Fetch the _meta query from a PostGraphile endpoint
+ */
+export 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,
+                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
+ */
+export 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/esm/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>;

package/esm/cli/introspect/fetch-schema.js

@@ -0,0 +1,83 @@
+/**
+ * Fetch GraphQL schema introspection from an endpoint
+ */
+import { SCHEMA_INTROSPECTION_QUERY } from './schema-query';
+/**
+ * Fetch the full schema introspection from a GraphQL endpoint
+ */
+export async function fetchSchema(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: SCHEMA_INTROSPECTION_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 __schema is present
+        if (!json.data?.__schema) {
+            return {
+                success: false,
+                error: 'No __schema field in response. Introspection may be disabled on this endpoint.',
+                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',
+        };
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Introspection module exports
+ */
+export { META_QUERY } from './meta-query';
+export type { MetaQueryResponse, MetaTable, MetaField, MetaFieldType, MetaConstraint, MetaForeignKeyConstraint, MetaTableQuery, MetaTableInflection, MetaBelongsToRelation, MetaHasRelation, MetaManyToManyRelation, MetaTableRelations, } from './meta-query';
+export { fetchMeta, validateEndpoint } from './fetch-meta';
+export type { FetchMetaOptions, FetchMetaResult } from './fetch-meta';
+export { transformMetaToCleanTables, getTableNames, findTable, filterTables, } from './transform';

package/esm/cli/introspect/index.js

@@ -0,0 +1,6 @@
+/**
+ * Introspection module exports
+ */
+export { META_QUERY } from './meta-query';
+export { fetchMeta, validateEndpoint } from './fetch-meta';
+export { transformMetaToCleanTables, getTableNames, findTable, filterTables, } from './transform';

package/esm/cli/introspect/meta-query.d.ts

@@ -0,0 +1,111 @@
+/**
+ * The _meta GraphQL query for introspecting PostGraphile schema
+ * This query fetches all table metadata including fields, constraints, and relations
+ */
+export declare const META_QUERY = "\nquery Meta {\n  _meta {\n    tables {\n      name\n      query {\n        all\n        create\n        delete\n        one\n        update\n      }\n      fields {\n        name\n        type {\n          gqlType\n          isArray\n          modifier\n          pgAlias\n          pgType\n          subtype\n          typmod\n        }\n      }\n      inflection {\n        allRows\n        allRowsSimple\n        conditionType\n        connection\n        createField\n        createInputType\n        createPayloadType\n        deleteByPrimaryKey\n        deletePayloadType\n        edge\n        edgeField\n        enumType\n        filterType\n        inputType\n        orderByType\n        patchField\n        patchType\n        tableFieldName\n        tableType\n        typeName\n        updateByPrimaryKey\n        updatePayloadType\n      }\n      primaryKeyConstraints {\n        name\n        fields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n      }\n      uniqueConstraints {\n        name\n        fields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n      }\n      foreignKeyConstraints {\n        name\n        fields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n        refFields {\n          name\n          type {\n            gqlType\n            isArray\n            modifier\n            pgAlias\n            pgType\n            subtype\n            typmod\n          }\n        }\n        refTable {\n          name\n        }\n      }\n      relations {\n        belongsTo {\n          fieldName\n          isUnique\n          keys {\n            name\n            type {\n              gqlType\n              isArray\n              modifier\n              pgAlias\n              pgType\n              subtype\n              typmod\n            }\n          }\n          references {\n            name\n          }\n          type\n        }\n        hasOne {\n          fieldName\n          isUnique\n          keys {\n            name\n            type {\n              gqlType\n              isArray\n              modifier\n              pgAlias\n              pgType\n              subtype\n              typmod\n            }\n          }\n          referencedBy {\n            name\n          }\n          type\n        }\n        hasMany {\n          fieldName\n          isUnique\n          keys {\n            name\n            type {\n              gqlType\n              isArray\n              modifier\n              pgAlias\n              pgType\n              subtype\n              typmod\n            }\n          }\n          referencedBy {\n            name\n          }\n          type\n        }\n        manyToMany {\n          fieldName\n          junctionTable {\n            name\n          }\n          rightTable {\n            name\n          }\n          type\n        }\n      }\n    }\n  }\n}\n";
+/**
+ * Types for the _meta query response
+ */
+export interface MetaFieldType {
+    gqlType: string;
+    isArray: boolean;
+    modifier: string | number | null;
+    pgAlias: string | null;
+    pgType: string | null;
+    subtype: string | null;
+    typmod: number | null;
+}
+export interface MetaField {
+    name: string;
+    type: MetaFieldType;
+}
+export interface MetaConstraint {
+    name: string;
+    fields: MetaField[];
+}
+export interface MetaForeignKeyConstraint extends MetaConstraint {
+    refFields: MetaField[];
+    refTable: {
+        name: string;
+    };
+}
+export interface MetaTableQuery {
+    all: string;
+    create: string;
+    delete: string | null;
+    one: string;
+    update: string | null;
+}
+export interface MetaTableInflection {
+    allRows: string;
+    allRowsSimple: string;
+    conditionType: string;
+    connection: string;
+    createField: string;
+    createInputType: string;
+    createPayloadType: string;
+    deleteByPrimaryKey: string | null;
+    deletePayloadType: string;
+    edge: string;
+    edgeField: string;
+    enumType: string;
+    filterType: string | null;
+    inputType: string;
+    orderByType: string;
+    patchField: string;
+    patchType: string | null;
+    tableFieldName: string;
+    tableType: string;
+    typeName: string;
+    updateByPrimaryKey: string | null;
+    updatePayloadType: string | null;
+}
+export interface MetaBelongsToRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    keys: MetaField[];
+    references: {
+        name: string;
+    };
+    type: string | null;
+}
+export interface MetaHasRelation {
+    fieldName: string | null;
+    isUnique: boolean;
+    keys: MetaField[];
+    referencedBy: {
+        name: string;
+    };
+    type: string | null;
+}
+export interface MetaManyToManyRelation {
+    fieldName: string | null;
+    junctionTable: {
+        name: string;
+    };
+    rightTable: {
+        name: string;
+    };
+    type: string | null;
+}
+export interface MetaTableRelations {
+    belongsTo: MetaBelongsToRelation[];
+    hasOne: MetaHasRelation[];
+    hasMany: MetaHasRelation[];
+    manyToMany: MetaManyToManyRelation[];
+}
+export interface MetaTable {
+    name: string;
+    query: MetaTableQuery;
+    fields: MetaField[];
+    inflection: MetaTableInflection;
+    primaryKeyConstraints: MetaConstraint[];
+    uniqueConstraints: MetaConstraint[];
+    foreignKeyConstraints: MetaForeignKeyConstraint[];
+    relations: MetaTableRelations;
+}
+export interface MetaQueryResponse {
+    _meta: {
+        tables: MetaTable[];
+    };
+}