@constructive-io/graphql-codegen 2.32.0 → 3.0.1

package/esm/core/introspect/source/pgpm-module.js

@@ -0,0 +1,194 @@
+/**
+ * PGPM Module Schema Source
+ *
+ * Loads GraphQL schema from a PGPM module by:
+ * 1. Creating an ephemeral database
+ * 2. Deploying the module to the database
+ * 3. Introspecting the database with PostGraphile
+ * 4. Cleaning up the ephemeral database (unless keepDb is true)
+ */
+import { buildSchema, introspectionFromSchema } from 'graphql';
+import { PgpmPackage } from '@pgpmjs/core';
+import { createEphemeralDb } from 'pgsql-client';
+import { deployPgpm } from 'pgsql-seed';
+import { getPgPool } from 'pg-cache';
+import { SchemaSourceError } from './types';
+import { buildSchemaSDLFromDatabase } from '../../database';
+import { resolveApiSchemas, validateServicesSchemas } from './api-schemas';
+/**
+ * Type guard to check if options use direct module path
+ */
+export function isPgpmModulePathOptions(options) {
+    return 'pgpmModulePath' in options;
+}
+/**
+ * Type guard to check if options use workspace + module name
+ */
+export function isPgpmWorkspaceOptions(options) {
+    return 'pgpmWorkspacePath' in options && 'pgpmModuleName' in options;
+}
+/**
+ * Schema source that loads from a PGPM module
+ *
+ * Creates an ephemeral database, deploys the module, introspects the schema,
+ * and cleans up. Supports both direct module path and workspace + module name modes.
+ */
+export class PgpmModuleSchemaSource {
+    options;
+    ephemeralDb = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async fetch() {
+        const keepDb = this.getKeepDb();
+        const apiNames = this.getApiNames();
+        // Resolve the module path
+        let modulePath;
+        try {
+            modulePath = this.resolveModulePath();
+        }
+        catch (err) {
+            throw new SchemaSourceError(`Failed to resolve module path: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+        }
+        // Validate the module exists
+        const pkg = new PgpmPackage(modulePath);
+        if (!pkg.isInModule()) {
+            throw new SchemaSourceError(`Not a valid PGPM module: ${modulePath}. Directory must contain pgpm.plan and .control files.`, this.describe());
+        }
+        // Create ephemeral database
+        try {
+            this.ephemeralDb = createEphemeralDb({
+                prefix: 'codegen_pgpm_',
+                verbose: false,
+            });
+        }
+        catch (err) {
+            throw new SchemaSourceError(`Failed to create ephemeral database: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+        }
+        const { config: dbConfig, teardown } = this.ephemeralDb;
+        try {
+            // Deploy the module to the ephemeral database
+            try {
+                await deployPgpm(dbConfig, modulePath, false);
+            }
+            catch (err) {
+                throw new SchemaSourceError(`Failed to deploy PGPM module: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+            }
+            // Resolve schemas - either from explicit schemas option or from apiNames (after deployment)
+            let schemas;
+            if (apiNames && apiNames.length > 0) {
+                // For PGPM mode, validate services schemas AFTER migration
+                const pool = getPgPool(dbConfig);
+                try {
+                    const validation = await validateServicesSchemas(pool);
+                    if (!validation.valid) {
+                        throw new SchemaSourceError(validation.error, this.describe());
+                    }
+                    schemas = await resolveApiSchemas(pool, apiNames);
+                }
+                catch (err) {
+                    if (err instanceof SchemaSourceError)
+                        throw err;
+                    throw new SchemaSourceError(`Failed to resolve API schemas: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+                }
+            }
+            else {
+                schemas = this.getSchemas();
+            }
+            // Build SDL from the deployed database
+            let sdl;
+            try {
+                sdl = await buildSchemaSDLFromDatabase({
+                    database: dbConfig.database,
+                    schemas,
+                });
+            }
+            catch (err) {
+                throw new SchemaSourceError(`Failed to introspect database: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+            }
+            // Validate non-empty
+            if (!sdl.trim()) {
+                throw new SchemaSourceError('Database introspection returned empty schema', this.describe());
+            }
+            // Parse SDL to GraphQL schema
+            let schema;
+            try {
+                schema = buildSchema(sdl);
+            }
+            catch (err) {
+                throw new SchemaSourceError(`Invalid GraphQL SDL from database: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+            }
+            // Convert to introspection format
+            let introspectionResult;
+            try {
+                introspectionResult = introspectionFromSchema(schema);
+            }
+            catch (err) {
+                throw new SchemaSourceError(`Failed to generate introspection: ${err instanceof Error ? err.message : 'Unknown error'}`, this.describe(), err instanceof Error ? err : undefined);
+            }
+            // Convert graphql-js introspection result to our mutable type
+            const introspection = JSON.parse(JSON.stringify(introspectionResult));
+            return { introspection };
+        }
+        finally {
+            // Clean up the ephemeral database
+            teardown({ keepDb });
+            if (keepDb) {
+                console.log(`[pgpm-module] Kept ephemeral database: ${dbConfig.database}`);
+            }
+        }
+    }
+    describe() {
+        const apiNames = this.getApiNames();
+        if (isPgpmModulePathOptions(this.options)) {
+            if (apiNames && apiNames.length > 0) {
+                return `pgpm module: ${this.options.pgpmModulePath} (apiNames: ${apiNames.join(', ')})`;
+            }
+            const schemas = this.options.schemas ?? ['public'];
+            return `pgpm module: ${this.options.pgpmModulePath} (schemas: ${schemas.join(', ')})`;
+        }
+        else {
+            if (apiNames && apiNames.length > 0) {
+                return `pgpm workspace: ${this.options.pgpmWorkspacePath}, module: ${this.options.pgpmModuleName} (apiNames: ${apiNames.join(', ')})`;
+            }
+            const schemas = this.options.schemas ?? ['public'];
+            return `pgpm workspace: ${this.options.pgpmWorkspacePath}, module: ${this.options.pgpmModuleName} (schemas: ${schemas.join(', ')})`;
+        }
+    }
+    resolveModulePath() {
+        if (isPgpmModulePathOptions(this.options)) {
+            return this.options.pgpmModulePath;
+        }
+        // Workspace + module name mode
+        const { pgpmWorkspacePath, pgpmModuleName } = this.options;
+        const workspace = new PgpmPackage(pgpmWorkspacePath);
+        if (!workspace.workspacePath) {
+            throw new Error(`Not a valid PGPM workspace: ${pgpmWorkspacePath}`);
+        }
+        // Get the module from the workspace
+        const moduleProject = workspace.getModuleProject(pgpmModuleName);
+        const modulePath = moduleProject.getModulePath();
+        if (!modulePath) {
+            throw new Error(`Module "${pgpmModuleName}" not found in workspace`);
+        }
+        return modulePath;
+    }
+    getSchemas() {
+        if (isPgpmModulePathOptions(this.options)) {
+            return this.options.schemas ?? ['public'];
+        }
+        return this.options.schemas ?? ['public'];
+    }
+    getApiNames() {
+        if (isPgpmModulePathOptions(this.options)) {
+            return this.options.apiNames;
+        }
+        return this.options.apiNames;
+    }
+    getKeepDb() {
+        if (isPgpmModulePathOptions(this.options)) {
+            return this.options.keepDb ?? false;
+        }
+        return this.options.keepDb ?? false;
+    }
+}

package/esm/core/output/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Output module exports
+ */
+export { writeGeneratedFiles, formatOutput, type GeneratedFile, type WriteResult, type WriteOptions, } from './writer';

package/esm/core/output/index.js

@@ -0,0 +1,4 @@
+/**
+ * Output module exports
+ */
+export { writeGeneratedFiles, formatOutput, } from './writer';

package/esm/core/output/writer.d.ts

@@ -0,0 +1,38 @@
+import type { GeneratedFile } from '../codegen';
+export type { GeneratedFile };
+/**
+ * Result of writing files
+ */
+export interface WriteResult {
+    success: boolean;
+    filesWritten?: string[];
+    errors?: string[];
+}
+/**
+ * Options for writing files
+ */
+export interface WriteOptions {
+    /** Show progress output (default: true) */
+    showProgress?: boolean;
+    /** Format files with oxfmt after writing (default: true) */
+    formatFiles?: boolean;
+}
+/**
+ * Write generated files to disk
+ *
+ * @param files - Array of files to write
+ * @param outputDir - Base output directory
+ * @param subdirs - Subdirectories to create
+ * @param options - Write options
+ */
+export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[], options?: WriteOptions): Promise<WriteResult>;
+/**
+ * Format generated files using oxfmt
+ *
+ * Runs oxfmt on the output directory after all files are written.
+ * Uses the same formatting options as prettier: single quotes, trailing commas, 2-space tabs, semicolons.
+ */
+export declare function formatOutput(outputDir: string): {
+    success: boolean;
+    error?: string;
+};

package/esm/core/output/writer.js

@@ -0,0 +1,119 @@
+/**
+ * File writing utilities
+ *
+ * Pure functions for writing generated files to disk and formatting them.
+ * These are core utilities that can be used programmatically or by the CLI.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+/**
+ * Write generated files to disk
+ *
+ * @param files - Array of files to write
+ * @param outputDir - Base output directory
+ * @param subdirs - Subdirectories to create
+ * @param options - Write options
+ */
+export async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
+    const { showProgress = true, formatFiles = 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 oxfmt
+    if (formatFiles && 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 oxfmt
+ *
+ * Runs oxfmt on the output directory after all files are written.
+ * Uses the same formatting options as prettier: single quotes, trailing commas, 2-space tabs, semicolons.
+ */
+export function formatOutput(outputDir) {
+    const absoluteOutputDir = path.resolve(outputDir);
+    try {
+        execSync(`npx oxfmt --write "${absoluteOutputDir}"`, {
+            stdio: 'pipe',
+            encoding: 'utf-8',
+        });
+        return { success: true };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: message };
+    }
+}

package/esm/{cli/commands/shared.d.ts → core/pipeline/index.d.ts}

@@ -8,18 +8,20 @@
  * - Operation transformation
  * - Filtering
  */
-import type { ResolvedConfig } from '../../types/config';
+import type { GraphQLSDKConfigTarget } from '../../types/config';
 import type { CleanTable, CleanOperation, TypeRegistry } from '../../types/schema';
 import type { SchemaSource } from '../introspect/source';
+export type { SchemaSource } from '../introspect/source';
+export { createSchemaSource, validateSourceOptions } from '../introspect/source';
 export interface CodegenPipelineOptions {
     /**
      * Schema source (endpoint or file)
      */
     source: SchemaSource;
     /**
-     * Resolved configuration
+     * Configuration
      */
-    config: ResolvedConfig;
+    config: GraphQLSDKConfigTarget;
     /**
      * Enable verbose logging
      */

package/esm/{cli/commands/shared.js → core/pipeline/index.js}

@@ -1,6 +1,7 @@
 import { inferTablesFromIntrospection } from '../introspect/infer-tables';
 import { filterTables } from '../introspect/transform';
 import { transformSchemaToOperations, filterOperations, getTableOperationNames, getCustomOperations, } from '../introspect/transform-schema';
+export { createSchemaSource, validateSourceOptions } from '../introspect/source';
 // ============================================================================
 // Main Pipeline
 // ============================================================================

package/esm/{cli → core}/watch/orchestrator.d.ts

@@ -3,10 +3,28 @@
  *
  * Coordinates schema polling, change detection, and code regeneration
  */
-import type { ResolvedConfig } from '../../types/config';
+import type { GraphQLSDKConfigTarget } from '../../types/config';
 import type { GeneratorType } from './types';
+export interface GenerateFunction {
+    (options: {
+        config?: string;
+        target?: string;
+        endpoint?: string;
+        output?: string;
+        authorization?: string;
+        verbose?: boolean;
+        skipCustomOperations?: boolean;
+    }): Promise<GenerateResult>;
+}
+export interface GenerateResult {
+    success: boolean;
+    message: string;
+    tables?: string[];
+    filesWritten?: string[];
+    errors?: string[];
+}
 export interface WatchOrchestratorOptions {
-    config: ResolvedConfig;
+    config: GraphQLSDKConfigTarget;
     generatorType: GeneratorType;
     verbose: boolean;
     authorization?: string;
@@ -14,10 +32,14 @@ export interface WatchOrchestratorOptions {
     configPath?: string;
     /** Target name for multi-target configs */
     target?: string;
-    /** Override output directory (for ORM) */
+    /** Override output directory */
     outputDir?: string;
     /** Skip custom operations flag */
     skipCustomOperations?: boolean;
+    /** Generator function for React Query SDK */
+    generateReactQuery: GenerateFunction;
+    /** Generator function for ORM client */
+    generateOrm: GenerateFunction;
 }
 export interface WatchStatus {
     isRunning: boolean;

package/esm/{cli → core}/watch/orchestrator.js

@@ -5,8 +5,6 @@
  */
 import { SchemaPoller } from './poller';
 import { debounce } from './debounce';
-import { generateReactQuery } from '../commands/generate';
-import { generateOrm, } from '../commands/generate-orm';
 /**
  * Main watch orchestrator class
  */
@@ -131,29 +129,31 @@ export class WatchOrchestrator {
         }
         this.log('Regenerating...');
         try {
-            let result;
-            if (this.options.generatorType === 'generate') {
-                result = await generateReactQuery({
-                    config: this.options.configPath,
-                    target: this.options.target,
-                    endpoint: this.options.config.endpoint,
-                    output: this.options.outputDir ?? this.options.config.output,
-                    authorization: this.options.authorization,
-                    verbose: this.watchOptions.verbose,
-                    skipCustomOperations: this.options.skipCustomOperations,
-                });
-            }
-            else {
-                result = await generateOrm({
-                    config: this.options.configPath,
-                    target: this.options.target,
-                    endpoint: this.options.config.endpoint,
-                    output: this.options.outputDir ?? this.options.config.orm.output,
-                    authorization: this.options.authorization,
-                    verbose: this.watchOptions.verbose,
-                    skipCustomOperations: this.options.skipCustomOperations,
-                });
+            let generateFn;
+            let outputDir;
+            switch (this.options.generatorType) {
+                case 'react-query':
+                    generateFn = this.options.generateReactQuery;
+                    // React Query hooks go to {output}/hooks
+                    outputDir = this.options.outputDir ?? `${this.options.config.output}/hooks`;
+                    break;
+                case 'orm':
+                    generateFn = this.options.generateOrm;
+                    // ORM client goes to {output}/orm
+                    outputDir = this.options.outputDir ?? `${this.options.config.output}/orm`;
+                    break;
+                default:
+                    throw new Error(`Unknown generator type: ${this.options.generatorType}`);
             }
+            const result = await generateFn({
+                config: this.options.configPath,
+                target: this.options.target,
+                endpoint: this.options.config.endpoint,
+                output: outputDir,
+                authorization: this.options.authorization,
+                verbose: this.watchOptions.verbose,
+                skipCustomOperations: this.options.skipCustomOperations,
+            });
             const duration = Date.now() - startTime;
             if (result.success) {
                 this.status.regenerateCount++;
@@ -193,9 +193,17 @@ export class WatchOrchestrator {
         process.stdout.write('\x1B[2J\x1B[0f');
     }
     logHeader() {
-        const generatorName = this.options.generatorType === 'generate'
-            ? 'React Query hooks'
-            : 'ORM client';
+        let generatorName;
+        switch (this.options.generatorType) {
+            case 'react-query':
+                generatorName = 'React Query hooks';
+                break;
+            case 'orm':
+                generatorName = 'ORM client';
+                break;
+            default:
+                throw new Error(`Unknown generator type: ${this.options.generatorType}`);
+        }
         console.log(`\n${'─'.repeat(50)}`);
         console.log(`graphql-codegen watch mode (${generatorName})`);
         console.log(`Endpoint: ${this.options.config.endpoint}`);

package/esm/{cli → core}/watch/types.d.ts

@@ -61,4 +61,4 @@ export interface PollEvent {
 /**
  * Generator type for watch mode
  */
-export type GeneratorType = 'generate' | 'generate-orm';
+export type GeneratorType = 'react-query' | 'orm';

package/esm/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * @constructive-io/graphql-codegen
  *
- * CLI-based GraphQL SDK generator for PostGraphile endpoints.
+ * GraphQL SDK generator for Constructive databases.
  * Introspects via _meta query and generates typed queries, mutations,
  * and React Query v5 hooks.
  */
@@ -10,5 +10,10 @@ export * from './core';
 export * from './generators';
 export * from './client';
 export { defineConfig } from './types/config';
-export { generateReactQuery, generateOrm, findConfigFile, loadConfigFile, } from './cli/commands';
-export type { GenerateOptions, GenerateResult, GenerateTargetResult, GenerateOrmOptions, GenerateOrmResult, GenerateOrmTargetResult, InitOptions, InitResult, } from './cli/commands';
+export { generate } from './core/generate';
+export type { GenerateOptions, GenerateResult } from './core/generate';
+export { findConfigFile, loadConfigFile } from './core/config';
+export { codegenQuestions, splitCommas, printResult } from './cli/shared';
+export type { CodegenAnswers } from './cli/shared';
+export { buildSchemaFromDatabase, buildSchemaSDLFromDatabase, } from './core/database';
+export type { BuildSchemaFromDatabaseOptions, BuildSchemaFromDatabaseResult, } from './core/database';

package/esm/index.js

@@ -1,7 +1,7 @@
 /**
  * @constructive-io/graphql-codegen
  *
- * CLI-based GraphQL SDK generator for PostGraphile endpoints.
+ * GraphQL SDK generator for Constructive databases.
  * Introspects via _meta query and generates typed queries, mutations,
  * and React Query v5 hooks.
  */
@@ -15,5 +15,11 @@ export * from './generators';
 export * from './client';
 // Config definition helper
 export { defineConfig } from './types/config';
-// CLI command exports (for packages/cli consumption)
-export { generateReactQuery, generateOrm, findConfigFile, loadConfigFile, } from './cli/commands';
+// Main generate function (orchestrates the entire pipeline)
+export { generate } from './core/generate';
+// Config utilities
+export { findConfigFile, loadConfigFile } from './core/config';
+// CLI shared utilities (for packages/cli to import)
+export { codegenQuestions, splitCommas, printResult } from './cli/shared';
+// Database schema utilities (re-exported from core for convenience)
+export { buildSchemaFromDatabase, buildSchemaSDLFromDatabase, } from './core/database';