@constructive-io/graphql-codegen 2.32.0 → 3.0.0

package/core/introspect/source/pgpm-module.d.ts

@@ -0,0 +1,83 @@
+import type { SchemaSource, SchemaSourceResult } from './types';
+/**
+ * Options for PGPM module schema source using direct module path
+ */
+export interface PgpmModulePathOptions {
+    /**
+     * Path to the PGPM module directory
+     * The directory should contain a pgpm.plan file and .control file
+     */
+    pgpmModulePath: string;
+    /**
+     * PostgreSQL schemas to include in introspection
+     * Mutually exclusive with apiNames
+     */
+    schemas?: string[];
+    /**
+     * API names to resolve schemas from
+     * Queries services_public.api_schemas to get schema names
+     * Mutually exclusive with schemas
+     */
+    apiNames?: string[];
+    /**
+     * If true, keeps the ephemeral database after introspection (useful for debugging)
+     * @default false
+     */
+    keepDb?: boolean;
+}
+/**
+ * Options for PGPM module schema source using workspace + module name
+ */
+export interface PgpmWorkspaceOptions {
+    /**
+     * Path to the PGPM workspace directory
+     * The directory should contain a pgpm.config.yaml or similar workspace config
+     */
+    pgpmWorkspacePath: string;
+    /**
+     * Name of the module within the workspace
+     */
+    pgpmModuleName: string;
+    /**
+     * PostgreSQL schemas to include in introspection
+     * Mutually exclusive with apiNames
+     */
+    schemas?: string[];
+    /**
+     * API names to resolve schemas from
+     * Queries services_public.api_schemas to get schema names
+     * Mutually exclusive with schemas
+     */
+    apiNames?: string[];
+    /**
+     * If true, keeps the ephemeral database after introspection (useful for debugging)
+     * @default false
+     */
+    keepDb?: boolean;
+}
+export type PgpmModuleSchemaSourceOptions = PgpmModulePathOptions | PgpmWorkspaceOptions;
+/**
+ * Type guard to check if options use direct module path
+ */
+export declare function isPgpmModulePathOptions(options: PgpmModuleSchemaSourceOptions): options is PgpmModulePathOptions;
+/**
+ * Type guard to check if options use workspace + module name
+ */
+export declare function isPgpmWorkspaceOptions(options: PgpmModuleSchemaSourceOptions): options is PgpmWorkspaceOptions;
+/**
+ * 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 declare class PgpmModuleSchemaSource implements SchemaSource {
+    private readonly options;
+    private ephemeralDb;
+    constructor(options: PgpmModuleSchemaSourceOptions);
+    fetch(): Promise<SchemaSourceResult>;
+    describe(): string;
+    private resolveModulePath;
+    private getSchemas;
+    private getApiNames;
+    private getKeepDb;
+}

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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgpmModuleSchemaSource = void 0;
+exports.isPgpmModulePathOptions = isPgpmModulePathOptions;
+exports.isPgpmWorkspaceOptions = isPgpmWorkspaceOptions;
+/**
+ * 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)
+ */
+const graphql_1 = require("graphql");
+const core_1 = require("@pgpmjs/core");
+const pgsql_client_1 = require("pgsql-client");
+const pgsql_seed_1 = require("pgsql-seed");
+const pg_cache_1 = require("pg-cache");
+const types_1 = require("./types");
+const database_1 = require("../../database");
+const api_schemas_1 = require("./api-schemas");
+/**
+ * Type guard to check if options use direct module path
+ */
+function isPgpmModulePathOptions(options) {
+    return 'pgpmModulePath' in options;
+}
+/**
+ * Type guard to check if options use workspace + module name
+ */
+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.
+ */
+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 types_1.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 core_1.PgpmPackage(modulePath);
+        if (!pkg.isInModule()) {
+            throw new types_1.SchemaSourceError(`Not a valid PGPM module: ${modulePath}. Directory must contain pgpm.plan and .control files.`, this.describe());
+        }
+        // Create ephemeral database
+        try {
+            this.ephemeralDb = (0, pgsql_client_1.createEphemeralDb)({
+                prefix: 'codegen_pgpm_',
+                verbose: false,
+            });
+        }
+        catch (err) {
+            throw new types_1.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 (0, pgsql_seed_1.deployPgpm)(dbConfig, modulePath, false);
+            }
+            catch (err) {
+                throw new types_1.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 = (0, pg_cache_1.getPgPool)(dbConfig);
+                try {
+                    const validation = await (0, api_schemas_1.validateServicesSchemas)(pool);
+                    if (!validation.valid) {
+                        throw new types_1.SchemaSourceError(validation.error, this.describe());
+                    }
+                    schemas = await (0, api_schemas_1.resolveApiSchemas)(pool, apiNames);
+                }
+                catch (err) {
+                    if (err instanceof types_1.SchemaSourceError)
+                        throw err;
+                    throw new types_1.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 (0, database_1.buildSchemaSDLFromDatabase)({
+                    database: dbConfig.database,
+                    schemas,
+                });
+            }
+            catch (err) {
+                throw new types_1.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 types_1.SchemaSourceError('Database introspection returned empty schema', this.describe());
+            }
+            // Parse SDL to GraphQL schema
+            let schema;
+            try {
+                schema = (0, graphql_1.buildSchema)(sdl);
+            }
+            catch (err) {
+                throw new types_1.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 = (0, graphql_1.introspectionFromSchema)(schema);
+            }
+            catch (err) {
+                throw new types_1.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 core_1.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;
+    }
+}
+exports.PgpmModuleSchemaSource = PgpmModuleSchemaSource;

package/core/output/index.d.ts

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

package/core/output/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Output module exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOutput = exports.writeGeneratedFiles = void 0;
+var writer_1 = require("./writer");
+Object.defineProperty(exports, "writeGeneratedFiles", { enumerable: true, get: function () { return writer_1.writeGeneratedFiles; } });
+Object.defineProperty(exports, "formatOutput", { enumerable: true, get: function () { return writer_1.formatOutput; } });

package/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/core/output/writer.js

@@ -0,0 +1,156 @@
+"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.writeGeneratedFiles = writeGeneratedFiles;
+exports.formatOutput = formatOutput;
+/**
+ * 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.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("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
+ */
+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.
+ */
+function formatOutput(outputDir) {
+    const absoluteOutputDir = path.resolve(outputDir);
+    try {
+        (0, node_child_process_1.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/{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/{cli/commands/shared.js → core/pipeline/index.js}

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSourceOptions = exports.createSchemaSource = void 0;
 exports.runCodegenPipeline = runCodegenPipeline;
 exports.validateTablesFound = validateTablesFound;
 const infer_tables_1 = require("../introspect/infer-tables");
 const transform_1 = require("../introspect/transform");
 const transform_schema_1 = require("../introspect/transform-schema");
+var source_1 = require("../introspect/source");
+Object.defineProperty(exports, "createSchemaSource", { enumerable: true, get: function () { return source_1.createSchemaSource; } });
+Object.defineProperty(exports, "validateSourceOptions", { enumerable: true, get: function () { return source_1.validateSourceOptions; } });
 // ============================================================================
 // Main Pipeline
 // ============================================================================

package/{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/{cli → core}/watch/orchestrator.js

@@ -9,8 +9,6 @@ exports.WatchOrchestrator = void 0;
 exports.startWatch = startWatch;
 const poller_1 = require("./poller");
 const debounce_1 = require("./debounce");
-const generate_1 = require("../commands/generate");
-const generate_orm_1 = require("../commands/generate-orm");
 /**
  * Main watch orchestrator class
  */
@@ -135,29 +133,31 @@ class WatchOrchestrator {
         }
         this.log('Regenerating...');
         try {
-            let result;
-            if (this.options.generatorType === 'generate') {
-                result = await (0, generate_1.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 (0, generate_orm_1.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++;
@@ -197,9 +197,17 @@ 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/{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';