@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/esm/cli/introspect/transform-schema.test.js

@@ -0,0 +1,65 @@
+// Jest globals - no import needed
+import { getTableOperationNames, getCustomOperations, isTableOperation, } from './transform-schema';
+describe('transform-schema table operation filtering', () => {
+    const dummyReturnType = { kind: 'SCALAR', name: 'String' };
+    it('detects table operations and update/delete patterns', () => {
+        const tableOps = getTableOperationNames([
+            {
+                name: 'User',
+                query: {
+                    all: 'users',
+                    one: 'user',
+                    create: 'createUser',
+                    update: 'updateUser',
+                    delete: 'deleteUser',
+                },
+                inflection: { tableType: 'User' },
+            },
+        ]);
+        const updateByEmail = {
+            name: 'updateUserByEmail',
+            kind: 'mutation',
+            args: [],
+            returnType: dummyReturnType,
+        };
+        const login = {
+            name: 'login',
+            kind: 'mutation',
+            args: [],
+            returnType: dummyReturnType,
+        };
+        expect(isTableOperation(updateByEmail, tableOps)).toBe(true);
+        expect(isTableOperation(login, tableOps)).toBe(false);
+    });
+    it('filters out table operations from custom list', () => {
+        const tableOps = getTableOperationNames([
+            {
+                name: 'User',
+                query: {
+                    all: 'users',
+                    one: 'user',
+                    create: 'createUser',
+                    update: 'updateUser',
+                    delete: 'deleteUser',
+                },
+                inflection: { tableType: 'User' },
+            },
+        ]);
+        const operations = [
+            {
+                name: 'users',
+                kind: 'query',
+                args: [],
+                returnType: dummyReturnType,
+            },
+            {
+                name: 'login',
+                kind: 'mutation',
+                args: [],
+                returnType: dummyReturnType,
+            },
+        ];
+        const customOps = getCustomOperations(operations, tableOps);
+        expect(customOps.map((op) => op.name)).toEqual(['login']);
+    });
+});

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

@@ -0,0 +1,21 @@
+/**
+ * Transform _meta query response to CleanTable[] format
+ */
+import type { CleanTable } from '../../types/schema';
+import type { MetaQueryResponse } from './meta-query';
+/**
+ * Transform _meta response to CleanTable array
+ */
+export declare function transformMetaToCleanTables(metaResponse: MetaQueryResponse): CleanTable[];
+/**
+ * Get table names from CleanTable array
+ */
+export declare function getTableNames(tables: CleanTable[]): string[];
+/**
+ * Find a table by name
+ */
+export declare function findTable(tables: CleanTable[], name: string): CleanTable | undefined;
+/**
+ * Filter tables by name pattern (glob-like)
+ */
+export declare function filterTables(tables: CleanTable[], include?: string[], exclude?: string[]): CleanTable[];

package/esm/cli/introspect/transform.js

@@ -0,0 +1,210 @@
+/**
+ * Transform _meta response to CleanTable array
+ */
+export function transformMetaToCleanTables(metaResponse) {
+    const { tables } = metaResponse._meta;
+    return tables.map((table) => transformTable(table));
+}
+/**
+ * Transform a single MetaTable to CleanTable
+ */
+function transformTable(table) {
+    return {
+        name: table.name,
+        fields: transformFields(table.fields),
+        relations: transformRelations(table.relations),
+        inflection: transformInflection(table.inflection),
+        query: transformQuery(table.query),
+        constraints: transformConstraints(table),
+    };
+}
+/**
+ * Transform MetaField[] to CleanField[]
+ */
+function transformFields(fields) {
+    return fields.map((field) => ({
+        name: field.name,
+        type: transformFieldType(field.type),
+    }));
+}
+/**
+ * Transform MetaFieldType to CleanFieldType
+ */
+function transformFieldType(type) {
+    return {
+        gqlType: type.gqlType,
+        isArray: type.isArray,
+        modifier: type.modifier,
+        pgAlias: type.pgAlias,
+        pgType: type.pgType,
+        subtype: type.subtype,
+        typmod: type.typmod,
+    };
+}
+/**
+ * Transform table relations
+ */
+function transformRelations(relations) {
+    return {
+        belongsTo: relations.belongsTo.map(transformBelongsTo),
+        hasOne: relations.hasOne.map(transformHasOne),
+        hasMany: relations.hasMany.map(transformHasMany),
+        manyToMany: relations.manyToMany.map(transformManyToMany),
+    };
+}
+/**
+ * Transform belongsTo relation
+ */
+function transformBelongsTo(rel) {
+    return {
+        fieldName: rel.fieldName,
+        isUnique: rel.isUnique,
+        referencesTable: rel.references.name,
+        type: rel.type,
+        keys: transformFields(rel.keys),
+    };
+}
+/**
+ * Transform hasOne relation
+ */
+function transformHasOne(rel) {
+    return {
+        fieldName: rel.fieldName,
+        isUnique: rel.isUnique,
+        referencedByTable: rel.referencedBy.name,
+        type: rel.type,
+        keys: transformFields(rel.keys),
+    };
+}
+/**
+ * Transform hasMany relation
+ */
+function transformHasMany(rel) {
+    return {
+        fieldName: rel.fieldName,
+        isUnique: rel.isUnique,
+        referencedByTable: rel.referencedBy.name,
+        type: rel.type,
+        keys: transformFields(rel.keys),
+    };
+}
+/**
+ * Transform manyToMany relation
+ */
+function transformManyToMany(rel) {
+    return {
+        fieldName: rel.fieldName,
+        rightTable: rel.rightTable.name,
+        junctionTable: rel.junctionTable.name,
+        type: rel.type,
+    };
+}
+/**
+ * Transform inflection data
+ */
+function transformInflection(inflection) {
+    return {
+        allRows: inflection.allRows,
+        allRowsSimple: inflection.allRowsSimple,
+        conditionType: inflection.conditionType,
+        connection: inflection.connection,
+        createField: inflection.createField,
+        createInputType: inflection.createInputType,
+        createPayloadType: inflection.createPayloadType,
+        deleteByPrimaryKey: inflection.deleteByPrimaryKey,
+        deletePayloadType: inflection.deletePayloadType,
+        edge: inflection.edge,
+        edgeField: inflection.edgeField,
+        enumType: inflection.enumType,
+        filterType: inflection.filterType,
+        inputType: inflection.inputType,
+        orderByType: inflection.orderByType,
+        patchField: inflection.patchField,
+        patchType: inflection.patchType,
+        tableFieldName: inflection.tableFieldName,
+        tableType: inflection.tableType,
+        typeName: inflection.typeName,
+        updateByPrimaryKey: inflection.updateByPrimaryKey,
+        updatePayloadType: inflection.updatePayloadType,
+    };
+}
+/**
+ * Transform query names
+ */
+function transformQuery(query) {
+    return {
+        all: query.all,
+        one: query.one,
+        create: query.create,
+        update: query.update,
+        delete: query.delete,
+    };
+}
+/**
+ * Transform constraints
+ */
+function transformConstraints(table) {
+    return {
+        primaryKey: table.primaryKeyConstraints.map(transformConstraint),
+        foreignKey: table.foreignKeyConstraints.map(transformForeignKeyConstraint),
+        unique: table.uniqueConstraints.map(transformConstraint),
+    };
+}
+/**
+ * Transform a basic constraint
+ */
+function transformConstraint(constraint) {
+    return {
+        name: constraint.name,
+        fields: transformFields(constraint.fields),
+    };
+}
+/**
+ * Transform a foreign key constraint
+ */
+function transformForeignKeyConstraint(constraint) {
+    return {
+        name: constraint.name,
+        fields: transformFields(constraint.fields),
+        refTable: constraint.refTable.name,
+        refFields: transformFields(constraint.refFields),
+    };
+}
+/**
+ * Get table names from CleanTable array
+ */
+export function getTableNames(tables) {
+    return tables.map((t) => t.name);
+}
+/**
+ * Find a table by name
+ */
+export function findTable(tables, name) {
+    return tables.find((t) => t.name === name);
+}
+/**
+ * Filter tables by name pattern (glob-like)
+ */
+export function filterTables(tables, include, exclude) {
+    let result = tables;
+    if (include && include.length > 0) {
+        result = result.filter((t) => matchesPatterns(t.name, include));
+    }
+    if (exclude && exclude.length > 0) {
+        result = result.filter((t) => !matchesPatterns(t.name, exclude));
+    }
+    return result;
+}
+/**
+ * Check if a name matches any of the patterns
+ * Supports simple glob patterns with * wildcard
+ */
+function matchesPatterns(name, patterns) {
+    return patterns.some((pattern) => {
+        if (pattern.includes('*')) {
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+            return regex.test(name);
+        }
+        return name === pattern;
+    });
+}

package/esm/cli/watch/cache.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+import type { MetaQueryResponse } from '../introspect/meta-query';
+import type { IntrospectionQueryResponse } from '../../types/introspection';
+/**
+ * Lightweight in-memory schema cache
+ * Only stores the combined hash string to detect changes
+ */
+export declare class SchemaCache {
+    /** Current schema hash (in-memory only) */
+    private currentHash;
+    /**
+     * Check if schema has changed by comparing hashes
+     * This is the hot path - must be efficient
+     */
+    hasChanged(meta: MetaQueryResponse, schema: IntrospectionQueryResponse): Promise<{
+        changed: boolean;
+        newHash: string;
+    }>;
+    /**
+     * Update the cached hash (call after successful regeneration)
+     */
+    updateHash(hash: string): void;
+    /**
+     * Get the current cached hash
+     */
+    getHash(): string | null;
+    /**
+     * Clear the cached hash
+     */
+    clear(): void;
+    /**
+     * Compute hash from meta and schema responses
+     */
+    private computeHash;
+}
+/**
+ * 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.
+ */
+export declare function touchFile(filePath: string): void;

package/esm/cli/watch/cache.js

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { hashObject, combineHashes } from './hash';
+/**
+ * Lightweight in-memory schema cache
+ * Only stores the combined hash string to detect changes
+ */
+export 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 hashObject(meta);
+        const schemaHash = await hashObject(schema);
+        return combineHashes(metaHash, schemaHash);
+    }
+}
+/**
+ * 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.
+ */
+export 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/esm/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/esm/cli/watch/debounce.js

@@ -0,0 +1,85 @@
+/**
+ * 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 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
+ */
+export 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/esm/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/esm/cli/watch/hash.js

@@ -0,0 +1,43 @@
+/**
+ * Schema hashing utilities using Node.js crypto.subtle (Node 22+)
+ */
+import { webcrypto } from 'node:crypto';
+/**
+ * Compute SHA-256 hash of a string using Web Crypto API
+ * Uses crypto.subtle available in Node.js 22+
+ */
+export async function sha256(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await 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
+ */
+export 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
+ */
+export async function combineHashes(...hashes) {
+    return sha256(hashes.join(':'));
+}

package/esm/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/esm/cli/watch/index.js

@@ -0,0 +1,8 @@
+/**
+ * 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';

package/esm/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>;