@constructive-io/graphql-codegen 2.20.1 → 2.22.0

package/cli/codegen/types.d.ts

@@ -3,10 +3,13 @@
  */
 import type { CleanTable } from '../../types/schema';
 /**
- * Generate types.ts content with all entity interfaces and base filter types
+ * Options for generating types.ts
  */
-export declare function generateTypesFile(tables: CleanTable[]): string;
+export interface GenerateTypesOptions {
+    /** Enum type names that are available from schema-types.ts */
+    enumsFromSchemaTypes?: string[];
+}
 /**
- * Generate a minimal entity type (just id and display fields)
+ * Generate types.ts content with all entity interfaces and base filter types
  */
-export declare function generateMinimalEntityType(table: CleanTable): string;
+export declare function generateTypesFile(tables: CleanTable[], options?: GenerateTypesOptions): string;

package/cli/codegen/types.js

@@ -1,19 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTypesFile = generateTypesFile;
-exports.generateMinimalEntityType = generateMinimalEntityType;
 const ts_ast_1 = require("./ts-ast");
 const utils_1 = require("./utils");
-const filters_1 = require("./filters");
+/** All filter type configurations - scalar and list filters */
+const FILTER_CONFIGS = [
+    // Scalar filters
+    { name: 'StringFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison', 'string'] },
+    { name: 'IntFilter', tsType: 'number', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'FloatFilter', tsType: 'number', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'BooleanFilter', tsType: 'boolean', operators: ['equality'] },
+    { name: 'UUIDFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray'] },
+    { name: 'DatetimeFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'DateFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'JSONFilter', tsType: 'Record<string, unknown>', operators: ['equality', 'distinct', 'json'] },
+    { name: 'BigIntFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'BigFloatFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison'] },
+    { name: 'BitStringFilter', tsType: 'string', operators: ['equality'] },
+    { name: 'InternetAddressFilter', tsType: 'string', operators: ['equality', 'distinct', 'inArray', 'comparison', 'inet'] },
+    { name: 'FullTextFilter', tsType: 'string', operators: ['fulltext'] },
+    // List filters
+    { name: 'StringListFilter', tsType: 'string[]', operators: ['equality', 'distinct', 'comparison', 'listArray'] },
+    { name: 'IntListFilter', tsType: 'number[]', operators: ['equality', 'distinct', 'comparison', 'listArray'] },
+    { name: 'UUIDListFilter', tsType: 'string[]', operators: ['equality', 'distinct', 'comparison', 'listArray'] },
+];
+/** Build filter properties based on operator sets */
+function buildFilterProperties(tsType, operators) {
+    const props = [];
+    // Equality operators (isNull, equalTo, notEqualTo)
+    if (operators.includes('equality')) {
+        props.push({ name: 'isNull', type: 'boolean', optional: true }, { name: 'equalTo', type: tsType, optional: true }, { name: 'notEqualTo', type: tsType, optional: true });
+    }
+    // Distinct operators
+    if (operators.includes('distinct')) {
+        props.push({ name: 'distinctFrom', type: tsType, optional: true }, { name: 'notDistinctFrom', type: tsType, optional: true });
+    }
+    // In array operators
+    if (operators.includes('inArray')) {
+        props.push({ name: 'in', type: `${tsType}[]`, optional: true }, { name: 'notIn', type: `${tsType}[]`, optional: true });
+    }
+    // Comparison operators (lt, lte, gt, gte)
+    if (operators.includes('comparison')) {
+        props.push({ name: 'lessThan', type: tsType, optional: true }, { name: 'lessThanOrEqualTo', type: tsType, optional: true }, { name: 'greaterThan', type: tsType, optional: true }, { name: 'greaterThanOrEqualTo', type: tsType, optional: true });
+    }
+    // String-specific operators
+    if (operators.includes('string')) {
+        props.push({ name: 'includes', type: 'string', optional: true }, { name: 'notIncludes', type: 'string', optional: true }, { name: 'includesInsensitive', type: 'string', optional: true }, { name: 'notIncludesInsensitive', type: 'string', optional: true }, { name: 'startsWith', type: 'string', optional: true }, { name: 'notStartsWith', type: 'string', optional: true }, { name: 'startsWithInsensitive', type: 'string', optional: true }, { name: 'notStartsWithInsensitive', type: 'string', optional: true }, { name: 'endsWith', type: 'string', optional: true }, { name: 'notEndsWith', type: 'string', optional: true }, { name: 'endsWithInsensitive', type: 'string', optional: true }, { name: 'notEndsWithInsensitive', type: 'string', optional: true }, { name: 'like', type: 'string', optional: true }, { name: 'notLike', type: 'string', optional: true }, { name: 'likeInsensitive', type: 'string', optional: true }, { name: 'notLikeInsensitive', type: 'string', optional: true });
+    }
+    // JSON-specific operators
+    if (operators.includes('json')) {
+        props.push({ name: 'contains', type: 'unknown', optional: true }, { name: 'containedBy', type: 'unknown', optional: true }, { name: 'containsKey', type: 'string', optional: true }, { name: 'containsAllKeys', type: 'string[]', optional: true }, { name: 'containsAnyKeys', type: 'string[]', optional: true });
+    }
+    // Internet address operators
+    if (operators.includes('inet')) {
+        props.push({ name: 'contains', type: 'string', optional: true }, { name: 'containedBy', type: 'string', optional: true }, { name: 'containsOrContainedBy', type: 'string', optional: true });
+    }
+    // Full-text search operator
+    if (operators.includes('fulltext')) {
+        props.push({ name: 'matches', type: 'string', optional: true });
+    }
+    // List/Array operators (for StringListFilter, IntListFilter, etc.)
+    if (operators.includes('listArray')) {
+        // Extract base type from array type (e.g., 'string[]' -> 'string')
+        const baseType = tsType.replace('[]', '');
+        props.push({ name: 'contains', type: tsType, optional: true }, { name: 'containedBy', type: tsType, optional: true }, { name: 'overlaps', type: tsType, optional: true }, { name: 'anyEqualTo', type: baseType, optional: true }, { name: 'anyNotEqualTo', type: baseType, optional: true }, { name: 'anyLessThan', type: baseType, optional: true }, { name: 'anyLessThanOrEqualTo', type: baseType, optional: true }, { name: 'anyGreaterThan', type: baseType, optional: true }, { name: 'anyGreaterThanOrEqualTo', type: baseType, optional: true });
+    }
+    return props;
+}
 /**
  * Generate types.ts content with all entity interfaces and base filter types
  */
-function generateTypesFile(tables) {
+function generateTypesFile(tables, options = {}) {
+    const { enumsFromSchemaTypes = [] } = options;
+    const enumSet = new Set(enumsFromSchemaTypes);
     const project = (0, ts_ast_1.createProject)();
     const sourceFile = (0, ts_ast_1.createSourceFile)(project, 'types.ts');
     // Add file header
     sourceFile.insertText(0, (0, ts_ast_1.createFileHeader)('Entity types and filter types') + '\n\n');
-    // Add section comment
+    // Collect which enums are actually used by entity fields
+    const usedEnums = new Set();
+    for (const table of tables) {
+        const scalarFields = (0, utils_1.getScalarFields)(table);
+        for (const field of scalarFields) {
+            // Check if the field's gqlType matches any known enum
+            const cleanType = field.type.gqlType.replace(/!/g, '');
+            if (enumSet.has(cleanType)) {
+                usedEnums.add(cleanType);
+            }
+        }
+    }
+    // Add import for enum types from schema-types if any are used
+    if (usedEnums.size > 0) {
+        sourceFile.addImportDeclaration((0, ts_ast_1.createImport)({
+            moduleSpecifier: './schema-types',
+            typeOnlyNamedImports: Array.from(usedEnums).sort(),
+        }));
+        sourceFile.addStatements('');
+    }
+    // Add section comment for entity types
     sourceFile.addStatements('// ============================================================================');
     sourceFile.addStatements('// Entity types');
     sourceFile.addStatements('// ============================================================================\n');
@@ -26,44 +110,13 @@ function generateTypesFile(tables) {
         }));
         sourceFile.addInterface((0, ts_ast_1.createInterface)(table.name, properties));
     }
-    // Add section comment for filters
+    // Add section comment for filter types
     sourceFile.addStatements('\n// ============================================================================');
-    sourceFile.addStatements('// Filter types (shared)');
+    sourceFile.addStatements('// Filter types (shared PostGraphile filter interfaces)');
     sourceFile.addStatements('// ============================================================================\n');
-    // Add base filter types (using string concat for complex types - acceptable for static definitions)
-    const filterTypesContent = (0, filters_1.generateBaseFilterTypes)();
-    // Extract just the interfaces part (skip the header)
-    const filterInterfaces = filterTypesContent
-        .split('\n')
-        .slice(6) // Skip header lines
-        .join('\n');
-    sourceFile.addStatements(filterInterfaces);
-    return (0, ts_ast_1.getFormattedOutput)(sourceFile);
-}
-/**
- * Generate a minimal entity type (just id and display fields)
- */
-function generateMinimalEntityType(table) {
-    const project = (0, ts_ast_1.createProject)();
-    const sourceFile = (0, ts_ast_1.createSourceFile)(project, 'minimal.ts');
-    const scalarFields = (0, utils_1.getScalarFields)(table);
-    // Find id and likely display fields
-    const displayFields = scalarFields.filter((f) => {
-        const name = f.name.toLowerCase();
-        return (name === 'id' ||
-            name === 'name' ||
-            name === 'title' ||
-            name === 'label' ||
-            name === 'email' ||
-            name.endsWith('name') ||
-            name.endsWith('title'));
-    });
-    // If no display fields found, take first 5 scalar fields
-    const fieldsToUse = displayFields.length > 0 ? displayFields : scalarFields.slice(0, 5);
-    const properties = fieldsToUse.map((field) => ({
-        name: field.name,
-        type: `${(0, utils_1.fieldTypeToTs)(field.type)} | null`,
-    }));
-    sourceFile.addInterface((0, ts_ast_1.createInterface)(`${table.name}Minimal`, properties));
+    // Generate all filter types
+    for (const { name, tsType, operators } of FILTER_CONFIGS) {
+        sourceFile.addInterface((0, ts_ast_1.createInterface)(name, buildFilterProperties(tsType, operators)));
+    }
     return (0, ts_ast_1.getFormattedOutput)(sourceFile);
 }

package/cli/codegen/utils.d.ts

@@ -134,8 +134,10 @@ export declare function gqlTypeToTs(gqlType: string, isArray?: boolean): string;
 export declare function fieldTypeToTs(fieldType: CleanFieldType): string;
 /**
  * Get the PostGraphile filter type for a GraphQL scalar
+ * @param gqlType - The GraphQL type string (e.g., "String", "UUID")
+ * @param isArray - Whether this is an array type
  */
-export declare function getScalarFilterType(gqlType: string): string | null;
+export declare function getScalarFilterType(gqlType: string, isArray?: boolean): string | null;
 /**
  * Check if a field is a relation field (not a scalar)
  */
@@ -145,7 +147,23 @@ export declare function isRelationField(fieldName: string, table: CleanTable): b
  */
 export declare function getScalarFields(table: CleanTable): CleanField[];
 /**
- * Get primary key field names
+ * Primary key field information
+ */
+export interface PrimaryKeyField {
+    /** Field name */
+    name: string;
+    /** GraphQL type (e.g., "UUID", "Int", "String") */
+    gqlType: string;
+    /** TypeScript type (e.g., "string", "number") */
+    tsType: string;
+}
+/**
+ * Get primary key field information from table constraints
+ * Returns array to support composite primary keys
+ */
+export declare function getPrimaryKeyInfo(table: CleanTable): PrimaryKeyField[];
+/**
+ * Get primary key field names (convenience wrapper)
  */
 export declare function getPrimaryKeyFields(table: CleanTable): string[];
 /**

package/cli/codegen/utils.js

@@ -32,6 +32,7 @@ exports.fieldTypeToTs = fieldTypeToTs;
 exports.getScalarFilterType = getScalarFilterType;
 exports.isRelationField = isRelationField;
 exports.getScalarFields = getScalarFields;
+exports.getPrimaryKeyInfo = getPrimaryKeyInfo;
 exports.getPrimaryKeyFields = getPrimaryKeyFields;
 exports.getQueryKeyPrefix = getQueryKeyPrefix;
 exports.getGeneratedFileHeader = getGeneratedFileHeader;
@@ -258,10 +259,12 @@ function fieldTypeToTs(fieldType) {
 // ============================================================================
 /**
  * Get the PostGraphile filter type for a GraphQL scalar
+ * @param gqlType - The GraphQL type string (e.g., "String", "UUID")
+ * @param isArray - Whether this is an array type
  */
-function getScalarFilterType(gqlType) {
+function getScalarFilterType(gqlType, isArray = false) {
     const cleanType = gqlType.replace(/!/g, '');
-    return (0, scalars_1.scalarToFilterType)(cleanType);
+    return (0, scalars_1.scalarToFilterType)(cleanType, isArray);
 }
 // ============================================================================
 // Field filtering utilities
@@ -283,13 +286,35 @@ function getScalarFields(table) {
     return table.fields.filter((f) => !isRelationField(f.name, table));
 }
 /**
- * Get primary key field names
+ * Get primary key field information from table constraints
+ * Returns array to support composite primary keys
  */
-function getPrimaryKeyFields(table) {
+function getPrimaryKeyInfo(table) {
     const pk = table.constraints?.primaryKey?.[0];
-    if (!pk)
-        return ['id']; // Default assumption
-    return pk.fields.map((f) => f.name);
+    if (!pk || pk.fields.length === 0) {
+        // Fallback: try to find 'id' field in table fields
+        const idField = table.fields.find(f => f.name.toLowerCase() === 'id');
+        if (idField) {
+            return [{
+                    name: idField.name,
+                    gqlType: idField.type.gqlType,
+                    tsType: fieldTypeToTs(idField.type),
+                }];
+        }
+        // Last resort: assume 'id' of type string (UUID)
+        return [{ name: 'id', gqlType: 'UUID', tsType: 'string' }];
+    }
+    return pk.fields.map((f) => ({
+        name: f.name,
+        gqlType: f.type.gqlType,
+        tsType: fieldTypeToTs(f.type),
+    }));
+}
+/**
+ * Get primary key field names (convenience wrapper)
+ */
+function getPrimaryKeyFields(table) {
+    return getPrimaryKeyInfo(table).map((pk) => pk.name);
 }
 // ============================================================================
 // Query key generation

package/cli/commands/generate-orm.js

@@ -114,16 +114,16 @@ async function generateOrmCommand(options = {}) {
         }
     }
     // 7. Generate ORM code
-    log('Generating ORM client...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = (0, orm_1.generateOrm)({
         tables,
         customOperations: customOperationsData,
         config,
     });
-    log(`  Generated ${stats.tables} table models`);
-    log(`  Generated ${stats.customQueries} custom query operations`);
-    log(`  Generated ${stats.customMutations} custom mutation operations`);
-    log(`  Total files: ${stats.totalFiles}`);
+    console.log(`Generated ${stats.totalFiles} files`);
+    log(`  ${stats.tables} table models`);
+    log(`  ${stats.customQueries} custom query operations`);
+    log(`  ${stats.customMutations} custom mutation operations`);
     if (options.dryRun) {
         return {
             success: true,

package/cli/commands/generate.d.ts

@@ -36,4 +36,7 @@ export interface WriteResult {
     filesWritten?: string[];
     errors?: string[];
 }
-export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[]): Promise<WriteResult>;
+export interface WriteOptions {
+    showProgress?: boolean;
+}
+export declare function writeGeneratedFiles(files: GeneratedFile[], outputDir: string, subdirs: string[], options?: WriteOptions): Promise<WriteResult>;

package/cli/commands/generate.js

@@ -149,17 +149,17 @@ async function generateCommand(options = {}) {
         }
     }
     // 7. Generate code
-    log('Generating code...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = (0, codegen_1.generate)({
         tables,
         customOperations: customOperationsData,
         config,
     });
-    log(`  Generated ${stats.queryHooks} table query hooks`);
-    log(`  Generated ${stats.mutationHooks} table mutation hooks`);
-    log(`  Generated ${stats.customQueryHooks} custom query hooks`);
-    log(`  Generated ${stats.customMutationHooks} custom mutation hooks`);
-    log(`  Total files: ${stats.totalFiles}`);
+    console.log(`Generated ${stats.totalFiles} files`);
+    log(`  ${stats.queryHooks} table query hooks`);
+    log(`  ${stats.mutationHooks} table mutation hooks`);
+    log(`  ${stats.customQueryHooks} custom query hooks`);
+    log(`  ${stats.customMutationHooks} custom mutation hooks`);
     if (options.dryRun) {
         return {
             success: true,
@@ -228,9 +228,12 @@ async function loadConfig(options) {
     const config = (0, config_1.resolveConfig)(mergedConfig);
     return { success: true, config };
 }
-async function writeGeneratedFiles(files, outputDir, subdirs) {
+async function writeGeneratedFiles(files, outputDir, subdirs, options = {}) {
+    const { showProgress = 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 });
@@ -256,8 +259,20 @@ async function writeGeneratedFiles(files, outputDir, subdirs) {
     if (errors.length > 0) {
         return { success: false, errors };
     }
-    for (const file of files) {
+    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 {
@@ -277,6 +292,10 @@ async function writeGeneratedFiles(files, outputDir, subdirs) {
             errors.push(`Failed to write ${filePath}: ${message}`);
         }
     }
+    // Clear progress line
+    if (showProgress && isTTY) {
+        process.stdout.write('\r' + ' '.repeat(40) + '\r');
+    }
     return {
         success: errors.length === 0,
         filesWritten: written,

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

@@ -30,13 +30,29 @@ export declare function transformSchemaToOperations(response: IntrospectionQuery
  * Uses glob-like patterns (supports * wildcard)
  */
 export declare function filterOperations(operations: CleanOperation[], include?: string[], exclude?: string[]): CleanOperation[];
+/**
+ * Result type for table operation names lookup
+ */
+export interface TableOperationNames {
+    queries: Set<string>;
+    mutations: Set<string>;
+}
 /**
  * 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)
+ * IMPORTANT: This uses EXACT matches only from _meta.query fields.
+ * Any operation not explicitly listed in _meta will flow through as a
+ * custom operation, ensuring 100% coverage of the schema.
+ *
+ * Table operations (generated by table generators):
+ * - Queries: all (list), one (single by PK)
+ * - Mutations: create, update (by PK), delete (by PK)
+ *
+ * Custom operations (generated by custom operation generators):
+ * - Unique constraint lookups: *ByUsername, *ByEmail, etc.
+ * - Unique constraint mutations: update*By*, delete*By*
+ * - True custom operations: login, register, bootstrapUser, etc.
  */
 export declare function getTableOperationNames(tables: Array<{
     name: string;
@@ -47,28 +63,24 @@ export declare function getTableOperationNames(tables: Array<{
         update: string | null;
         delete: string | null;
     };
-    inflection?: {
-        tableType: string;
-    };
-}>): {
-    queries: Set<string>;
-    mutations: Set<string>;
-    tableTypePatterns: RegExp[];
-};
+}>): TableOperationNames;
 /**
  * Check if an operation is a table operation (already handled by table generators)
+ *
+ * Uses EXACT match only - no pattern matching. This ensures:
+ * 1. Only operations explicitly in _meta.query are treated as table operations
+ * 2. All other operations (including update*By*, delete*By*) become custom operations
+ * 3. 100% schema coverage is guaranteed
  */
-export declare function isTableOperation(operation: CleanOperation, tableOperationNames: {
-    queries: Set<string>;
-    mutations: Set<string>;
-    tableTypePatterns: RegExp[];
-}): boolean;
+export declare function isTableOperation(operation: CleanOperation, tableOperationNames: TableOperationNames): boolean;
 /**
  * Get only custom operations (not covered by table generators)
+ *
+ * This returns ALL operations that are not exact matches for table CRUD operations.
+ * Includes:
+ * - Unique constraint queries (*ByUsername, *ByEmail, etc.)
+ * - Unique constraint mutations (update*By*, delete*By*)
+ * - True custom operations (login, register, bootstrapUser, etc.)
  */
-export declare function getCustomOperations(operations: CleanOperation[], tableOperationNames: {
-    queries: Set<string>;
-    mutations: Set<string>;
-    tableTypePatterns: RegExp[];
-}): CleanOperation[];
+export declare function getCustomOperations(operations: CleanOperation[], tableOperationNames: TableOperationNames): CleanOperation[];
 export { unwrapType, getBaseTypeName, isNonNull };

package/cli/introspect/transform-schema.js

@@ -38,6 +38,10 @@ function buildTypeRegistry(types) {
         if (type.kind === 'ENUM' && type.enumValues) {
             resolvedType.enumValues = type.enumValues.map((ev) => ev.name);
         }
+        // Resolve possible types for UNION types (no circular refs for names)
+        if (type.kind === 'UNION' && type.possibleTypes) {
+            resolvedType.possibleTypes = type.possibleTypes.map((pt) => pt.name);
+        }
         registry.set(type.name, resolvedType);
     }
     // Second pass: Resolve fields (now that all types exist in registry)
@@ -212,57 +216,63 @@ function matchesPatterns(name, patterns) {
         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)
+ * IMPORTANT: This uses EXACT matches only from _meta.query fields.
+ * Any operation not explicitly listed in _meta will flow through as a
+ * custom operation, ensuring 100% coverage of the schema.
+ *
+ * Table operations (generated by table generators):
+ * - Queries: all (list), one (single by PK)
+ * - Mutations: create, update (by PK), delete (by PK)
+ *
+ * Custom operations (generated by custom operation generators):
+ * - Unique constraint lookups: *ByUsername, *ByEmail, etc.
+ * - Unique constraint mutations: update*By*, delete*By*
+ * - True custom operations: login, register, bootstrapUser, etc.
  */
 function getTableOperationNames(tables) {
     const queries = new Set();
     const mutations = new Set();
-    const tableTypePatterns = [];
     for (const table of tables) {
         if (table.query) {
+            // Add exact query names from _meta
             queries.add(table.query.all);
             queries.add(table.query.one);
+            // Add exact mutation names from _meta
             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 };
+    return { queries, mutations };
 }
 /**
  * Check if an operation is a table operation (already handled by table generators)
+ *
+ * Uses EXACT match only - no pattern matching. This ensures:
+ * 1. Only operations explicitly in _meta.query are treated as table operations
+ * 2. All other operations (including update*By*, delete*By*) become custom operations
+ * 3. 100% schema coverage is guaranteed
  */
 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));
+    return tableOperationNames.mutations.has(operation.name);
 }
 /**
  * Get only custom operations (not covered by table generators)
+ *
+ * This returns ALL operations that are not exact matches for table CRUD operations.
+ * Includes:
+ * - Unique constraint queries (*ByUsername, *ByEmail, etc.)
+ * - Unique constraint mutations (update*By*, delete*By*)
+ * - True custom operations (login, register, bootstrapUser, etc.)
  */
 function getCustomOperations(operations, tableOperationNames) {
     return operations.filter((op) => !isTableOperation(op, tableOperationNames));

package/esm/cli/codegen/barrel.d.ts

@@ -15,8 +15,11 @@ export declare function generateQueriesBarrel(tables: CleanTable[]): string;
 export declare function generateMutationsBarrel(tables: CleanTable[]): string;
 /**
  * Generate the main index.ts barrel file
+ *
+ * @param tables - The tables to include in the SDK
+ * @param hasSchemaTypes - Whether schema-types.ts was generated
  */
-export declare function generateMainBarrel(tables: CleanTable[]): string;
+export declare function generateMainBarrel(tables: CleanTable[], hasSchemaTypes?: boolean): string;
 /**
  * Generate queries barrel including custom query operations
  */

package/esm/cli/codegen/barrel.js

@@ -5,10 +5,7 @@ import { getOperationHookName } from './type-resolver';
  * Generate the queries/index.ts barrel file
  */
 export function generateQueriesBarrel(tables) {
-    const lines = [
-        createFileHeader('Query hooks barrel export'),
-        '',
-    ];
+    const lines = [createFileHeader('Query hooks barrel export'), ''];
     // Export all query hooks
     for (const table of tables) {
         const listHookName = getListQueryHookName(table);
@@ -44,31 +41,40 @@ export function generateMutationsBarrel(tables) {
 }
 /**
  * Generate the main index.ts barrel file
+ *
+ * @param tables - The tables to include in the SDK
+ * @param hasSchemaTypes - Whether schema-types.ts was generated
  */
-export function generateMainBarrel(tables) {
+export function generateMainBarrel(tables, hasSchemaTypes = false) {
     const tableNames = tables.map((t) => t.name).join(', ');
+    const schemaTypesExport = hasSchemaTypes
+        ? `
+// Schema types (input, payload, enum types)
+export * from './schema-types';
+`
+        : '';
     return `/**
  * Auto-generated GraphQL SDK
  * @generated by @constructive-io/graphql-codegen
- * 
+ *
  * Tables: ${tableNames}
- * 
+ *
  * Usage:
- * 
+ *
  * 1. Configure the client:
  * \`\`\`ts
  * import { configure } from './generated';
- * 
+ *
  * configure({
  *   endpoint: 'https://api.example.com/graphql',
  *   headers: { Authorization: 'Bearer <token>' },
  * });
  * \`\`\`
- * 
+ *
  * 2. Use the hooks:
  * \`\`\`tsx
  * import { useCarsQuery, useCreateCarMutation } from './generated';
- * 
+ *
  * function MyComponent() {
  *   const { data, isLoading } = useCarsQuery({ first: 10 });
  *   const { mutate } = useCreateCarMutation();
@@ -82,7 +88,7 @@ export * from './client';
 
 // Entity and filter types
 export * from './types';
-
+${schemaTypesExport}
 // Query hooks
 export * from './queries';