@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/cli/watch/cache.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * In-memory schema cache for watch mode
+ *
+ * Only stores the hash in memory - no file I/O during normal operation.
+ * Touch file feature is optional and only writes when explicitly configured.
+ */
+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.SchemaCache = void 0;
+exports.touchFile = touchFile;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const hash_1 = require("./hash");
+/**
+ * Lightweight in-memory schema cache
+ * Only stores the combined hash string to detect changes
+ */
+class SchemaCache {
+    /** Current schema hash (in-memory only) */
+    currentHash = null;
+    /**
+     * Check if schema has changed by comparing hashes
+     * This is the hot path - must be efficient
+     */
+    async hasChanged(meta, schema) {
+        const newHash = await this.computeHash(meta, schema);
+        const changed = this.currentHash === null || this.currentHash !== newHash;
+        return { changed, newHash };
+    }
+    /**
+     * Update the cached hash (call after successful regeneration)
+     */
+    updateHash(hash) {
+        this.currentHash = hash;
+    }
+    /**
+     * Get the current cached hash
+     */
+    getHash() {
+        return this.currentHash;
+    }
+    /**
+     * Clear the cached hash
+     */
+    clear() {
+        this.currentHash = null;
+    }
+    /**
+     * Compute hash from meta and schema responses
+     */
+    async computeHash(meta, schema) {
+        // Hash each response separately then combine
+        // This is more efficient than stringifying both together
+        const metaHash = await (0, hash_1.hashObject)(meta);
+        const schemaHash = await (0, hash_1.hashObject)(schema);
+        return (0, hash_1.combineHashes)(metaHash, schemaHash);
+    }
+}
+exports.SchemaCache = SchemaCache;
+/**
+ * Touch a file to signal schema change (for external tools like tsc/webpack)
+ * This is the only file I/O in watch mode, and it's optional.
+ */
+function touchFile(filePath) {
+    // Ensure parent directory exists
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    // Touch the file (create if doesn't exist, update mtime if it does)
+    const time = new Date();
+    try {
+        fs.utimesSync(filePath, time, time);
+    }
+    catch {
+        fs.closeSync(fs.openSync(filePath, 'w'));
+    }
+}

package/cli/watch/debounce.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Debounce utility for regeneration
+ */
+/**
+ * Creates a debounced function that delays invoking func until after wait milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ */
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, wait: number): {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+    flush: () => void;
+};
+/**
+ * Creates an async debounced function
+ */
+export declare function debounceAsync<T extends (...args: unknown[]) => Promise<unknown>>(func: T, wait: number): {
+    (...args: Parameters<T>): Promise<void>;
+    cancel: () => void;
+};

package/cli/watch/debounce.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Debounce utility for regeneration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = debounce;
+exports.debounceAsync = debounceAsync;
+/**
+ * Creates a debounced function that delays invoking func until after wait milliseconds
+ * have elapsed since the last time the debounced function was invoked.
+ */
+function debounce(func, wait) {
+    let timeoutId = null;
+    let lastArgs = null;
+    const debounced = (...args) => {
+        lastArgs = args;
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = null;
+            if (lastArgs) {
+                func(...lastArgs);
+                lastArgs = null;
+            }
+        }, wait);
+    };
+    debounced.cancel = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+            lastArgs = null;
+        }
+    };
+    debounced.flush = () => {
+        if (timeoutId && lastArgs) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+            func(...lastArgs);
+            lastArgs = null;
+        }
+    };
+    return debounced;
+}
+/**
+ * Creates an async debounced function
+ */
+function debounceAsync(func, wait) {
+    let timeoutId = null;
+    let pendingPromise = null;
+    let pendingResolve = null;
+    const debounced = (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        // If there's already a pending promise, reuse it
+        if (!pendingPromise) {
+            pendingPromise = new Promise((resolve) => {
+                pendingResolve = resolve;
+            });
+        }
+        timeoutId = setTimeout(async () => {
+            timeoutId = null;
+            try {
+                await func(...args);
+            }
+            finally {
+                if (pendingResolve) {
+                    pendingResolve();
+                    pendingResolve = null;
+                    pendingPromise = null;
+                }
+            }
+        }, wait);
+        return pendingPromise;
+    };
+    debounced.cancel = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            timeoutId = null;
+        }
+        if (pendingResolve) {
+            pendingResolve();
+            pendingResolve = null;
+            pendingPromise = null;
+        }
+    };
+    return debounced;
+}

package/cli/watch/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Schema hashing utilities using Node.js crypto.subtle (Node 22+)
+ */
+/**
+ * Compute SHA-256 hash of a string using Web Crypto API
+ * Uses crypto.subtle available in Node.js 22+
+ */
+export declare function sha256(data: string): Promise<string>;
+/**
+ * Compute hash of an object by JSON-stringifying it
+ * Objects are sorted by keys for consistent hashing
+ */
+export declare function hashObject(obj: unknown): Promise<string>;
+/**
+ * Combine multiple hashes into a single hash
+ */
+export declare function combineHashes(...hashes: string[]): Promise<string>;

package/cli/watch/hash.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Schema hashing utilities using Node.js crypto.subtle (Node 22+)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.hashObject = hashObject;
+exports.combineHashes = combineHashes;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Compute SHA-256 hash of a string using Web Crypto API
+ * Uses crypto.subtle available in Node.js 22+
+ */
+async function sha256(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await node_crypto_1.webcrypto.subtle.digest('SHA-256', dataBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+/**
+ * Compute hash of an object by JSON-stringifying it
+ * Objects are sorted by keys for consistent hashing
+ */
+async function hashObject(obj) {
+    const json = JSON.stringify(obj, sortReplacer);
+    return sha256(json);
+}
+/**
+ * JSON.stringify replacer that sorts object keys for deterministic output
+ */
+function sortReplacer(_key, value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return Object.keys(value)
+            .sort()
+            .reduce((sorted, key) => {
+            sorted[key] = value[key];
+            return sorted;
+        }, {});
+    }
+    return value;
+}
+/**
+ * Combine multiple hashes into a single hash
+ */
+async function combineHashes(...hashes) {
+    return sha256(hashes.join(':'));
+}

package/cli/watch/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Watch mode module exports
+ */
+export { SchemaPoller, computeSchemaHash } from './poller';
+export { SchemaCache, touchFile } from './cache';
+export { sha256, hashObject, combineHashes } from './hash';
+export { debounce, debounceAsync } from './debounce';
+export { WatchOrchestrator, startWatch } from './orchestrator';
+export type { PollResult, WatchOptions, PollEventType, PollEventHandler, PollEvent, GeneratorType, } from './types';
+export type { WatchOrchestratorOptions, WatchStatus } from './orchestrator';

package/cli/watch/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Watch mode module exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatch = exports.WatchOrchestrator = exports.debounceAsync = exports.debounce = exports.combineHashes = exports.hashObject = exports.sha256 = exports.touchFile = exports.SchemaCache = exports.computeSchemaHash = exports.SchemaPoller = void 0;
+var poller_1 = require("./poller");
+Object.defineProperty(exports, "SchemaPoller", { enumerable: true, get: function () { return poller_1.SchemaPoller; } });
+Object.defineProperty(exports, "computeSchemaHash", { enumerable: true, get: function () { return poller_1.computeSchemaHash; } });
+var cache_1 = require("./cache");
+Object.defineProperty(exports, "SchemaCache", { enumerable: true, get: function () { return cache_1.SchemaCache; } });
+Object.defineProperty(exports, "touchFile", { enumerable: true, get: function () { return cache_1.touchFile; } });
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "sha256", { enumerable: true, get: function () { return hash_1.sha256; } });
+Object.defineProperty(exports, "hashObject", { enumerable: true, get: function () { return hash_1.hashObject; } });
+Object.defineProperty(exports, "combineHashes", { enumerable: true, get: function () { return hash_1.combineHashes; } });
+var debounce_1 = require("./debounce");
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return debounce_1.debounce; } });
+Object.defineProperty(exports, "debounceAsync", { enumerable: true, get: function () { return debounce_1.debounceAsync; } });
+var orchestrator_1 = require("./orchestrator");
+Object.defineProperty(exports, "WatchOrchestrator", { enumerable: true, get: function () { return orchestrator_1.WatchOrchestrator; } });
+Object.defineProperty(exports, "startWatch", { enumerable: true, get: function () { return orchestrator_1.startWatch; } });

package/cli/watch/orchestrator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Watch mode orchestrator
+ *
+ * Coordinates schema polling, change detection, and code regeneration
+ */
+import type { ResolvedConfig } from '../../types/config';
+import type { GeneratorType } from './types';
+export interface WatchOrchestratorOptions {
+    config: ResolvedConfig;
+    generatorType: GeneratorType;
+    verbose: boolean;
+    authorization?: string;
+    /** Override output directory (for ORM) */
+    outputDir?: string;
+    /** Skip custom operations flag */
+    skipCustomOperations?: boolean;
+}
+export interface WatchStatus {
+    isRunning: boolean;
+    pollCount: number;
+    regenerateCount: number;
+    lastPollTime: number | null;
+    lastRegenTime: number | null;
+    lastError: string | null;
+    currentHash: string | null;
+}
+/**
+ * Main watch orchestrator class
+ */
+export declare class WatchOrchestrator {
+    private options;
+    private watchOptions;
+    private poller;
+    private status;
+    private debouncedRegenerate;
+    private isShuttingDown;
+    constructor(options: WatchOrchestratorOptions);
+    private buildWatchOptions;
+    private setupEventHandlers;
+    /**
+     * Start watch mode
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watch mode
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current watch status
+     */
+    getStatus(): WatchStatus;
+    private regenerate;
+    private setupSignalHandlers;
+    private clearScreen;
+    private logHeader;
+    private log;
+    private logSuccess;
+    private logError;
+}
+/**
+ * Start watch mode for a generator
+ */
+export declare function startWatch(options: WatchOrchestratorOptions): Promise<void>;

package/cli/watch/orchestrator.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Watch mode orchestrator
+ *
+ * Coordinates schema polling, change detection, and code regeneration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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
+ */
+class WatchOrchestrator {
+    options;
+    watchOptions;
+    poller;
+    status;
+    debouncedRegenerate;
+    isShuttingDown = false;
+    constructor(options) {
+        this.options = options;
+        this.watchOptions = this.buildWatchOptions();
+        this.poller = new poller_1.SchemaPoller(this.watchOptions);
+        this.status = {
+            isRunning: false,
+            pollCount: 0,
+            regenerateCount: 0,
+            lastPollTime: null,
+            lastRegenTime: null,
+            lastError: null,
+            currentHash: null,
+        };
+        // Create debounced regenerate function
+        this.debouncedRegenerate = (0, debounce_1.debounce)(() => this.regenerate(), options.config.watch.debounce);
+        // Set up event handlers
+        this.setupEventHandlers();
+    }
+    buildWatchOptions() {
+        const { config, verbose, authorization } = this.options;
+        return {
+            endpoint: config.endpoint,
+            authorization,
+            headers: config.headers,
+            pollInterval: config.watch.pollInterval,
+            debounce: config.watch.debounce,
+            touchFile: config.watch.touchFile,
+            clearScreen: config.watch.clearScreen,
+            verbose,
+        };
+    }
+    setupEventHandlers() {
+        this.poller.on('poll-start', () => {
+            this.status.pollCount++;
+            if (this.watchOptions.verbose) {
+                this.log('Polling endpoint...');
+            }
+        });
+        this.poller.on('poll-success', (event) => {
+            this.status.lastPollTime = event.timestamp;
+            this.status.lastError = null;
+            if (this.watchOptions.verbose) {
+                this.log(`Poll complete (${event.duration}ms)`);
+            }
+        });
+        this.poller.on('poll-error', (event) => {
+            this.status.lastError = event.error ?? 'Unknown error';
+            this.logError(`Poll failed: ${event.error}`);
+        });
+        this.poller.on('schema-changed', (event) => {
+            this.status.currentHash = event.hash ?? null;
+            this.log(`Schema changed! (${event.duration}ms)`);
+            this.debouncedRegenerate();
+        });
+        this.poller.on('schema-unchanged', () => {
+            if (this.watchOptions.verbose) {
+                this.log('Schema unchanged');
+            }
+        });
+    }
+    /**
+     * Start watch mode
+     */
+    async start() {
+        if (this.status.isRunning) {
+            return;
+        }
+        this.status.isRunning = true;
+        this.setupSignalHandlers();
+        // Clear screen on start if configured
+        if (this.watchOptions.clearScreen) {
+            this.clearScreen();
+        }
+        this.logHeader();
+        // Do initial generation (always generate on start, regardless of cache)
+        this.log('Running initial generation...');
+        await this.regenerate();
+        // Seed the in-memory cache with current schema hash (silent, no events)
+        // This prevents the first poll from triggering another regeneration
+        await this.poller.seedCache();
+        // Start polling loop
+        this.poller.start();
+        this.log(`Watching for schema changes (poll interval: ${this.watchOptions.pollInterval}ms)`);
+    }
+    /**
+     * Stop watch mode
+     */
+    async stop() {
+        if (!this.status.isRunning) {
+            return;
+        }
+        this.isShuttingDown = true;
+        this.debouncedRegenerate.cancel();
+        this.poller.stop();
+        this.status.isRunning = false;
+        this.log('Watch mode stopped');
+    }
+    /**
+     * Get current watch status
+     */
+    getStatus() {
+        return { ...this.status };
+    }
+    async regenerate() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        const startTime = Date.now();
+        if (this.watchOptions.clearScreen) {
+            this.clearScreen();
+            this.logHeader();
+        }
+        this.log('Regenerating...');
+        try {
+            let result;
+            if (this.options.generatorType === 'generate') {
+                result = await (0, generate_1.generateCommand)({
+                    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.generateOrmCommand)({
+                    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,
+                });
+            }
+            const duration = Date.now() - startTime;
+            if (result.success) {
+                this.status.regenerateCount++;
+                this.status.lastRegenTime = Date.now();
+                this.logSuccess(`Generated in ${duration}ms`);
+                if (result.tables && result.tables.length > 0) {
+                    this.log(`  Tables: ${result.tables.length}`);
+                }
+                if (result.filesWritten && result.filesWritten.length > 0) {
+                    this.log(`  Files: ${result.filesWritten.length}`);
+                }
+            }
+            else {
+                this.logError(`Generation failed: ${result.message}`);
+                if (result.errors) {
+                    result.errors.forEach((e) => this.logError(`  ${e}`));
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Unknown error';
+            this.logError(`Generation error: ${message}`);
+        }
+        this.log(`\nWatching for changes...`);
+    }
+    setupSignalHandlers() {
+        const shutdown = async (signal) => {
+            this.log(`\nReceived ${signal}, shutting down...`);
+            await this.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+    }
+    clearScreen() {
+        // ANSI escape codes for clearing screen
+        process.stdout.write('\x1B[2J\x1B[0f');
+    }
+    logHeader() {
+        const generatorName = this.options.generatorType === 'generate'
+            ? 'React Query hooks'
+            : 'ORM client';
+        console.log(`\n${'─'.repeat(50)}`);
+        console.log(`graphql-codegen watch mode (${generatorName})`);
+        console.log(`Endpoint: ${this.options.config.endpoint}`);
+        console.log(`${'─'.repeat(50)}\n`);
+    }
+    log(message) {
+        const timestamp = new Date().toLocaleTimeString();
+        console.log(`[${timestamp}] ${message}`);
+    }
+    logSuccess(message) {
+        const timestamp = new Date().toLocaleTimeString();
+        console.log(`[${timestamp}] ✓ ${message}`);
+    }
+    logError(message) {
+        const timestamp = new Date().toLocaleTimeString();
+        console.error(`[${timestamp}] ✗ ${message}`);
+    }
+}
+exports.WatchOrchestrator = WatchOrchestrator;
+/**
+ * Start watch mode for a generator
+ */
+async function startWatch(options) {
+    const orchestrator = new WatchOrchestrator(options);
+    await orchestrator.start();
+    // Keep the process alive
+    await new Promise(() => {
+        // This promise never resolves - the process will exit via signal handlers
+    });
+}

package/cli/watch/poller.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Schema polling logic with EventEmitter pattern
+ *
+ * Uses in-memory hash comparison for efficiency.
+ * No file I/O during normal polling - only touchFile is optional file write.
+ */
+import { EventEmitter } from 'node:events';
+import type { MetaQueryResponse } from '../introspect/meta-query';
+import type { IntrospectionQueryResponse } from '../../types/introspection';
+import { SchemaCache } from './cache';
+import type { PollResult, WatchOptions } from './types';
+/**
+ * Schema poller that periodically introspects a GraphQL endpoint
+ * and emits events when the schema changes.
+ *
+ * Uses in-memory caching for hash comparison - no file I/O overhead.
+ */
+export declare class SchemaPoller extends EventEmitter {
+    private options;
+    private cache;
+    private pollTimer;
+    private isPolling;
+    private consecutiveErrors;
+    private readonly MAX_CONSECUTIVE_ERRORS;
+    constructor(options: WatchOptions);
+    /**
+     * Start the polling loop
+     */
+    start(): void;
+    /**
+     * Stop the polling loop
+     */
+    stop(): void;
+    /**
+     * Perform a single poll operation
+     */
+    poll(): Promise<PollResult>;
+    /**
+     * Perform a single poll without starting the loop (for initial generation)
+     */
+    pollOnce(): Promise<PollResult>;
+    /**
+     * Seed the cache with current schema hash without emitting events.
+     * Call this after initial generation to prevent first poll from triggering regeneration.
+     */
+    seedCache(): Promise<void>;
+    /**
+     * Get the current cached schema hash
+     */
+    getCurrentHash(): string | null;
+    /**
+     * Get the cache instance for direct access
+     */
+    getCache(): SchemaCache;
+    /**
+     * Check if the poller is currently running
+     */
+    isRunning(): boolean;
+    private handleError;
+    private createEvent;
+}
+/**
+ * Utility to compute schema hash without full poll
+ */
+export declare function computeSchemaHash(meta: MetaQueryResponse, schema: IntrospectionQueryResponse): Promise<string>;