@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/cli/introspect/transform-schema.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNonNull = exports.getBaseTypeName = exports.unwrapType = void 0;
+exports.buildTypeRegistry = buildTypeRegistry;
+exports.transformSchemaToOperations = transformSchemaToOperations;
+exports.filterOperations = filterOperations;
+exports.getTableOperationNames = getTableOperationNames;
+exports.isTableOperation = isTableOperation;
+exports.getCustomOperations = getCustomOperations;
+const introspection_1 = require("../../types/introspection");
+Object.defineProperty(exports, "unwrapType", { enumerable: true, get: function () { return introspection_1.unwrapType; } });
+Object.defineProperty(exports, "getBaseTypeName", { enumerable: true, get: function () { return introspection_1.getBaseTypeName; } });
+Object.defineProperty(exports, "isNonNull", { enumerable: true, get: function () { return introspection_1.isNonNull; } });
+// ============================================================================
+// Type Registry Builder
+// ============================================================================
+/**
+ * Build a type registry from introspection types
+ * Maps type names to their full resolved definitions
+ *
+ * This is a two-pass process to handle circular references:
+ * 1. First pass: Create all type entries with basic info
+ * 2. Second pass: Resolve fields with references to other types
+ */
+function buildTypeRegistry(types) {
+    const registry = new Map();
+    // First pass: Create all type entries
+    for (const type of types) {
+        // Skip built-in types that start with __
+        if (type.name.startsWith('__'))
+            continue;
+        const resolvedType = {
+            kind: type.kind,
+            name: type.name,
+            description: type.description ?? undefined,
+        };
+        // Resolve enum values for ENUM types (no circular refs possible)
+        if (type.kind === 'ENUM' && type.enumValues) {
+            resolvedType.enumValues = type.enumValues.map((ev) => ev.name);
+        }
+        registry.set(type.name, resolvedType);
+    }
+    // Second pass: Resolve fields (now that all types exist in registry)
+    for (const type of types) {
+        if (type.name.startsWith('__'))
+            continue;
+        const resolvedType = registry.get(type.name);
+        if (!resolvedType)
+            continue;
+        // Resolve fields for OBJECT types
+        if (type.kind === 'OBJECT' && type.fields) {
+            resolvedType.fields = type.fields.map((field) => transformFieldToCleanObjectFieldShallow(field));
+        }
+        // Resolve input fields for INPUT_OBJECT types
+        if (type.kind === 'INPUT_OBJECT' && type.inputFields) {
+            resolvedType.inputFields = type.inputFields.map((field) => transformInputValueToCleanArgumentShallow(field));
+        }
+    }
+    return registry;
+}
+/**
+ * Transform field to CleanObjectField without resolving nested types
+ * (shallow transformation to avoid circular refs)
+ */
+function transformFieldToCleanObjectFieldShallow(field) {
+    return {
+        name: field.name,
+        type: transformTypeRefShallow(field.type),
+        description: field.description ?? undefined,
+    };
+}
+/**
+ * Transform input value to CleanArgument without resolving nested types
+ */
+function transformInputValueToCleanArgumentShallow(inputValue) {
+    return {
+        name: inputValue.name,
+        type: transformTypeRefShallow(inputValue.type),
+        defaultValue: inputValue.defaultValue ?? undefined,
+        description: inputValue.description ?? undefined,
+    };
+}
+/**
+ * Transform TypeRef without resolving nested types
+ * Only handles wrappers (LIST, NON_NULL) and stores the type name
+ */
+function transformTypeRefShallow(typeRef) {
+    const cleanRef = {
+        kind: typeRef.kind,
+        name: typeRef.name,
+    };
+    if (typeRef.ofType) {
+        cleanRef.ofType = transformTypeRefShallow(typeRef.ofType);
+    }
+    return cleanRef;
+}
+/**
+ * Transform introspection response to clean operations
+ */
+function transformSchemaToOperations(response) {
+    const { __schema: schema } = response;
+    const { types, queryType, mutationType } = schema;
+    // Build type registry first
+    const typeRegistry = buildTypeRegistry(types);
+    // Find Query and Mutation types
+    const queryTypeDef = types.find((t) => t.name === queryType.name);
+    const mutationTypeDef = mutationType
+        ? types.find((t) => t.name === mutationType.name)
+        : null;
+    // Transform queries
+    const queries = queryTypeDef?.fields
+        ? queryTypeDef.fields.map((field) => transformFieldToCleanOperation(field, 'query', types))
+        : [];
+    // Transform mutations
+    const mutations = mutationTypeDef?.fields
+        ? mutationTypeDef.fields.map((field) => transformFieldToCleanOperation(field, 'mutation', types))
+        : [];
+    return { queries, mutations, typeRegistry };
+}
+// ============================================================================
+// Field to Operation Transformation
+// ============================================================================
+/**
+ * Transform an introspection field to a CleanOperation
+ */
+function transformFieldToCleanOperation(field, kind, types) {
+    return {
+        name: field.name,
+        kind,
+        args: field.args.map((arg) => transformInputValueToCleanArgument(arg, types)),
+        returnType: transformTypeRefToCleanTypeRef(field.type, types),
+        description: field.description ?? undefined,
+        isDeprecated: field.isDeprecated,
+        deprecationReason: field.deprecationReason ?? undefined,
+    };
+}
+/**
+ * Transform an input value to CleanArgument
+ */
+function transformInputValueToCleanArgument(inputValue, types) {
+    return {
+        name: inputValue.name,
+        type: transformTypeRefToCleanTypeRef(inputValue.type, types),
+        defaultValue: inputValue.defaultValue ?? undefined,
+        description: inputValue.description ?? undefined,
+    };
+}
+// ============================================================================
+// Type Reference Transformation
+// ============================================================================
+/**
+ * Transform an introspection TypeRef to CleanTypeRef
+ * Recursively handles wrapper types (LIST, NON_NULL)
+ *
+ * NOTE: We intentionally do NOT resolve nested fields here to avoid
+ * infinite recursion from circular type references. Fields are resolved
+ * lazily via the TypeRegistry when needed for code generation.
+ */
+function transformTypeRefToCleanTypeRef(typeRef, types) {
+    const cleanRef = {
+        kind: typeRef.kind,
+        name: typeRef.name,
+    };
+    // Recursively transform ofType for wrappers (LIST, NON_NULL)
+    if (typeRef.ofType) {
+        cleanRef.ofType = transformTypeRefToCleanTypeRef(typeRef.ofType, types);
+    }
+    // For named types, only resolve enum values (they don't have circular refs)
+    // Fields are NOT resolved here - they're resolved via TypeRegistry during codegen
+    if (typeRef.name && !typeRef.ofType) {
+        const typeDef = types.find((t) => t.name === typeRef.name);
+        if (typeDef) {
+            // Add enum values for ENUM types (safe, no recursion)
+            if (typeDef.kind === 'ENUM' && typeDef.enumValues) {
+                cleanRef.enumValues = typeDef.enumValues.map((ev) => ev.name);
+            }
+            // NOTE: OBJECT and INPUT_OBJECT fields are resolved via TypeRegistry
+            // to avoid circular reference issues
+        }
+    }
+    return cleanRef;
+}
+// ============================================================================
+// Operation Filtering
+// ============================================================================
+/**
+ * Filter operations by include/exclude patterns
+ * Uses glob-like patterns (supports * wildcard)
+ */
+function filterOperations(operations, include, exclude) {
+    let result = operations;
+    if (include && include.length > 0) {
+        result = result.filter((op) => matchesPatterns(op.name, include));
+    }
+    if (exclude && exclude.length > 0) {
+        result = result.filter((op) => !matchesPatterns(op.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 === '*')
+            return true;
+        if (pattern.includes('*')) {
+            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+            return regex.test(name);
+        }
+        return name === pattern;
+    });
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+/**
+ * Get the set of table-related operation names from tables
+ * Used to identify which operations are already covered by table generators
+ *
+ * This includes:
+ * - Basic CRUD: all, one, create, update, delete
+ * - PostGraphile alternate mutations: updateXByY, deleteXByY (for unique constraints)
+ */
+function getTableOperationNames(tables) {
+    const queries = new Set();
+    const mutations = new Set();
+    const tableTypePatterns = [];
+    for (const table of tables) {
+        if (table.query) {
+            queries.add(table.query.all);
+            queries.add(table.query.one);
+            mutations.add(table.query.create);
+            if (table.query.update)
+                mutations.add(table.query.update);
+            if (table.query.delete)
+                mutations.add(table.query.delete);
+        }
+        // Create patterns to match alternate CRUD mutations (updateXByY, deleteXByY)
+        if (table.inflection?.tableType) {
+            const typeName = table.inflection.tableType;
+            // Match: update{TypeName}By*, delete{TypeName}By*
+            tableTypePatterns.push(new RegExp(`^update${typeName}By`, 'i'));
+            tableTypePatterns.push(new RegExp(`^delete${typeName}By`, 'i'));
+        }
+    }
+    return { queries, mutations, tableTypePatterns };
+}
+/**
+ * Check if an operation is a table operation (already handled by table generators)
+ */
+function isTableOperation(operation, tableOperationNames) {
+    if (operation.kind === 'query') {
+        return tableOperationNames.queries.has(operation.name);
+    }
+    // Check exact match first
+    if (tableOperationNames.mutations.has(operation.name)) {
+        return true;
+    }
+    // Check pattern match for alternate CRUD mutations (updateXByY, deleteXByY)
+    return tableOperationNames.tableTypePatterns.some((pattern) => pattern.test(operation.name));
+}
+/**
+ * Get only custom operations (not covered by table generators)
+ */
+function getCustomOperations(operations, tableOperationNames) {
+    return operations.filter((op) => !isTableOperation(op, tableOperationNames));
+}

package/cli/introspect/transform-schema.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,67 @@
+"use strict";
+// Jest globals - no import needed
+Object.defineProperty(exports, "__esModule", { value: true });
+const transform_schema_1 = require("./transform-schema");
+describe('transform-schema table operation filtering', () => {
+    const dummyReturnType = { kind: 'SCALAR', name: 'String' };
+    it('detects table operations and update/delete patterns', () => {
+        const tableOps = (0, transform_schema_1.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((0, transform_schema_1.isTableOperation)(updateByEmail, tableOps)).toBe(true);
+        expect((0, transform_schema_1.isTableOperation)(login, tableOps)).toBe(false);
+    });
+    it('filters out table operations from custom list', () => {
+        const tableOps = (0, transform_schema_1.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 = (0, transform_schema_1.getCustomOperations)(operations, tableOps);
+        expect(customOps.map((op) => op.name)).toEqual(['login']);
+    });
+});

package/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/cli/introspect/transform.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformMetaToCleanTables = transformMetaToCleanTables;
+exports.getTableNames = getTableNames;
+exports.findTable = findTable;
+exports.filterTables = filterTables;
+/**
+ * Transform _meta response to CleanTable array
+ */
+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
+ */
+function getTableNames(tables) {
+    return tables.map((t) => t.name);
+}
+/**
+ * Find a table by name
+ */
+function findTable(tables, name) {
+    return tables.find((t) => t.name === name);
+}
+/**
+ * Filter tables by name pattern (glob-like)
+ */
+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/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;