@constructive-io/graphql-codegen 2.19.0 → 2.20.0

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

@@ -0,0 +1,39 @@
+export interface GenerateOptions {
+    /** Path to config file */
+    config?: string;
+    /** GraphQL endpoint URL (overrides config) */
+    endpoint?: 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 GenerateResult {
+    success: boolean;
+    message: string;
+    tables?: string[];
+    customQueries?: string[];
+    customMutations?: string[];
+    filesWritten?: string[];
+    errors?: string[];
+}
+/**
+ * Execute the generate command
+ */
+export declare function generateCommand(options?: GenerateOptions): Promise<GenerateResult>;
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export interface WriteResult {
+    success: boolean;
+    filesWritten?: string[];
+    errors?: string[];
+}
+export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[]): Promise<WriteResult>;

package/esm/cli/commands/generate.js

@@ -0,0 +1,262 @@
+/**
+ * Generate command - introspects endpoint and generates SDK
+ *
+ * This command:
+ * 1. Fetches _meta query for table-based CRUD operations
+ * 2. Fetches __schema introspection for ALL operations
+ * 3. Filters out table operations from custom operations to avoid duplicates
+ * 4. Generates hooks for both table CRUD and custom operations
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as prettier from 'prettier';
+import { resolveConfig } from '../../types/config';
+import { fetchMeta, validateEndpoint } from '../introspect/fetch-meta';
+import { fetchSchema } from '../introspect/fetch-schema';
+import { transformMetaToCleanTables, filterTables, } from '../introspect/transform';
+import { transformSchemaToOperations, filterOperations, getTableOperationNames, getCustomOperations, } from '../introspect/transform-schema';
+import { findConfigFile, loadConfigFile } from './init';
+import { generate } from '../codegen';
+/**
+ * Execute the generate command
+ */
+export async function generateCommand(options = {}) {
+    const log = options.verbose ? console.log : () => { };
+    // 1. Load config
+    log('Loading configuration...');
+    const configResult = await loadConfig(options);
+    if (!configResult.success) {
+        return {
+            success: false,
+            message: configResult.error,
+        };
+    }
+    const config = configResult.config;
+    log(`  Endpoint: ${config.endpoint}`);
+    log(`  Output: ${config.output}`);
+    // 2. Validate endpoint
+    const endpointValidation = validateEndpoint(config.endpoint);
+    if (!endpointValidation.valid) {
+        return {
+            success: false,
+            message: `Invalid endpoint: ${endpointValidation.error}`,
+        };
+    }
+    // Build authorization header if provided
+    const authHeader = options.authorization || config.headers['Authorization'];
+    // 3. Fetch _meta for table-based operations
+    log('Fetching schema metadata (_meta)...');
+    const metaResult = await fetchMeta({
+        endpoint: config.endpoint,
+        authorization: authHeader,
+        headers: config.headers,
+        timeout: 30000,
+    });
+    if (!metaResult.success) {
+        return {
+            success: false,
+            message: `Failed to fetch _meta: ${metaResult.error}`,
+        };
+    }
+    // 4. Transform to CleanTable[]
+    log('Transforming table schema...');
+    let tables = transformMetaToCleanTables(metaResult.data);
+    log(`  Found ${tables.length} tables`);
+    // 5. Filter tables
+    tables = filterTables(tables, config.tables.include, config.tables.exclude);
+    log(`  After filtering: ${tables.length} tables`);
+    if (tables.length === 0) {
+        return {
+            success: false,
+            message: 'No tables found after filtering. Check your include/exclude patterns.',
+        };
+    }
+    // Get table operation names for filtering custom operations
+    const tableOperationNames = getTableOperationNames(tables);
+    // 6. Fetch __schema for custom operations (unless skipped)
+    let customQueries = [];
+    let customMutations = [];
+    let customOperationsData;
+    if (!options.skipCustomOperations) {
+        log('Fetching schema introspection (__schema)...');
+        const schemaResult = await fetchSchema({
+            endpoint: config.endpoint,
+            authorization: authHeader,
+            headers: config.headers,
+            timeout: 30000,
+        });
+        if (schemaResult.success && schemaResult.data) {
+            log('Transforming custom operations...');
+            // Transform to CleanOperation[]
+            const { queries: allQueries, mutations: allMutations, typeRegistry } = transformSchemaToOperations(schemaResult.data);
+            log(`  Found ${allQueries.length} queries and ${allMutations.length} mutations total`);
+            // Filter by config include/exclude
+            const filteredQueries = filterOperations(allQueries, config.queries.include, config.queries.exclude);
+            const filteredMutations = filterOperations(allMutations, config.mutations.include, config.mutations.exclude);
+            log(`  After config filtering: ${filteredQueries.length} queries, ${filteredMutations.length} mutations`);
+            // Remove table operations (already handled by table generators)
+            const customQueriesOps = getCustomOperations(filteredQueries, tableOperationNames);
+            const customMutationsOps = getCustomOperations(filteredMutations, tableOperationNames);
+            log(`  Custom operations: ${customQueriesOps.length} queries, ${customMutationsOps.length} mutations`);
+            customQueries = customQueriesOps.map((q) => q.name);
+            customMutations = customMutationsOps.map((m) => m.name);
+            customOperationsData = {
+                queries: customQueriesOps,
+                mutations: customMutationsOps,
+                typeRegistry,
+            };
+        }
+        else {
+            log(`  Warning: Could not fetch __schema: ${schemaResult.error}`);
+            log('  Continuing with table-only generation...');
+        }
+    }
+    // 7. Generate code
+    log('Generating code...');
+    const { files: generatedFiles, stats } = generate({
+        tables,
+        customOperations: customOperationsData,
+        config,
+    });
+    log(`  Generated ${stats.queryHooks} table query hooks`);
+    log(`  Generated ${stats.mutationHooks} table mutation hooks`);
+    log(`  Generated ${stats.customQueryHooks} custom query hooks`);
+    log(`  Generated ${stats.customMutationHooks} custom mutation hooks`);
+    log(`  Total files: ${stats.totalFiles}`);
+    if (options.dryRun) {
+        return {
+            success: true,
+            message: `Dry run complete. Would generate ${generatedFiles.length} files for ${tables.length} tables and ${customQueries.length + customMutations.length} custom operations.`,
+            tables: tables.map((t) => t.name),
+            customQueries,
+            customMutations,
+            filesWritten: generatedFiles.map((f) => f.path),
+        };
+    }
+    // 8. Write files
+    log('Writing files...');
+    const writeResult = await writeGeneratedFiles(generatedFiles, config.output, ['queries', 'mutations']);
+    if (!writeResult.success) {
+        return {
+            success: false,
+            message: `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 {
+        success: true,
+        message: `Generated SDK for ${tables.length} tables${customOpsMsg}. Files written to ${config.output}`,
+        tables: tables.map((t) => t.name),
+        customQueries,
+        customMutations,
+        filesWritten: writeResult.filesWritten,
+    };
+}
+async function loadConfig(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) {
+            return { success: false, error: loadResult.error };
+        }
+        baseConfig = loadResult.config;
+    }
+    // Override with CLI options
+    const mergedConfig = {
+        endpoint: options.endpoint || baseConfig.endpoint || '',
+        output: options.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,
+    };
+    if (!mergedConfig.endpoint) {
+        return {
+            success: false,
+            error: 'No endpoint specified. Use --endpoint or create a config file with "graphql-codegen init".',
+        };
+    }
+    // Resolve with defaults
+    const config = resolveConfig(mergedConfig);
+    return { success: true, config };
+}
+export async function writeGeneratedFiles(files, outputDir, subdirs) {
+    const errors = [];
+    const written = [];
+    // 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 (const file of files) {
+        const filePath = path.join(outputDir, file.path);
+        // Ensure parent directory exists
+        const parentDir = path.dirname(filePath);
+        try {
+            fs.mkdirSync(parentDir, { recursive: true });
+        }
+        catch {
+            // Ignore if already exists
+        }
+        try {
+            // Format with prettier
+            const formattedContent = await formatCode(file.content);
+            fs.writeFileSync(filePath, formattedContent, 'utf-8');
+            written.push(filePath);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            errors.push(`Failed to write ${filePath}: ${message}`);
+        }
+    }
+    return {
+        success: errors.length === 0,
+        filesWritten: written,
+        errors: errors.length > 0 ? errors : undefined,
+    };
+}
+async function formatCode(code) {
+    try {
+        return await prettier.format(code, {
+            parser: 'typescript',
+            singleQuote: true,
+            trailingComma: 'es5',
+            tabWidth: 2,
+        });
+    }
+    catch {
+        // If prettier fails, return unformatted code
+        return code;
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * CLI commands exports
+ */
+export { initCommand, findConfigFile, loadConfigFile } from './init';
+export type { InitOptions, InitResult } from './init';
+export { generateCommand } from './generate';
+export type { GenerateOptions, GenerateResult } from './generate';

package/esm/cli/commands/index.js

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

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

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

@@ -0,0 +1,138 @@
+/**
+ * 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: 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) {
+    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 = 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/esm/cli/index.d.ts

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