@constructive-io/graphql-codegen 2.20.1 → 2.22.0

package/esm/cli/codegen/types.js

@@ -1,15 +1,100 @@
-import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createInterface, } from './ts-ast';
+import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, createInterface, } from './ts-ast';
 import { getScalarFields, fieldTypeToTs } from './utils';
-import { generateBaseFilterTypes } from './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
  */
-export function generateTypesFile(tables) {
+export function generateTypesFile(tables, options = {}) {
+    const { enumsFromSchemaTypes = [] } = options;
+    const enumSet = new Set(enumsFromSchemaTypes);
     const project = createProject();
     const sourceFile = createSourceFile(project, 'types.ts');
     // Add file header
     sourceFile.insertText(0, 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 = 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(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');
@@ -22,44 +107,13 @@ export function generateTypesFile(tables) {
         }));
         sourceFile.addInterface(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 = 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 getFormattedOutput(sourceFile);
-}
-/**
- * Generate a minimal entity type (just id and display fields)
- */
-export function generateMinimalEntityType(table) {
-    const project = createProject();
-    const sourceFile = createSourceFile(project, 'minimal.ts');
-    const scalarFields = 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: `${fieldTypeToTs(field.type)} | null`,
-    }));
-    sourceFile.addInterface(createInterface(`${table.name}Minimal`, properties));
+    // Generate all filter types
+    for (const { name, tsType, operators } of FILTER_CONFIGS) {
+        sourceFile.addInterface(createInterface(name, buildFilterProperties(tsType, operators)));
+    }
     return getFormattedOutput(sourceFile);
 }

package/esm/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/esm/cli/codegen/utils.js

@@ -220,10 +220,12 @@ export 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
  */
-export function getScalarFilterType(gqlType) {
+export function getScalarFilterType(gqlType, isArray = false) {
     const cleanType = gqlType.replace(/!/g, '');
-    return scalarToFilterType(cleanType);
+    return scalarToFilterType(cleanType, isArray);
 }
 // ============================================================================
 // Field filtering utilities
@@ -245,13 +247,35 @@ export 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
  */
-export function getPrimaryKeyFields(table) {
+export 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)
+ */
+export function getPrimaryKeyFields(table) {
+    return getPrimaryKeyInfo(table).map((pk) => pk.name);
 }
 // ============================================================================
 // Query key generation

package/esm/cli/commands/generate-orm.js

@@ -111,16 +111,16 @@ export async function generateOrmCommand(options = {}) {
         }
     }
     // 7. Generate ORM code
-    log('Generating ORM client...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = 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/esm/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/esm/cli/commands/generate.js

@@ -112,17 +112,17 @@ export async function generateCommand(options = {}) {
         }
     }
     // 7. Generate code
-    log('Generating code...');
+    console.log('Generating code...');
     const { files: generatedFiles, stats } = 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,
@@ -191,9 +191,12 @@ async function loadConfig(options) {
     const config = resolveConfig(mergedConfig);
     return { success: true, config };
 }
-export async function writeGeneratedFiles(files, outputDir, subdirs) {
+export 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 });
@@ -219,8 +222,20 @@ export 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 {
@@ -240,6 +255,10 @@ export 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/esm/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/esm/cli/introspect/transform-schema.js

@@ -26,6 +26,10 @@ export 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)
@@ -200,57 +204,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.
  */
 export 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
  */
 export 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.)
  */
 export function getCustomOperations(operations, tableOperationNames) {
     return operations.filter((op) => !isTableOperation(op, tableOperationNames));

package/esm/types/config.d.ts

@@ -95,6 +95,18 @@ export interface GraphQLSDKConfig {
          */
         useSharedTypes?: boolean;
     };
+    /**
+     * React Query integration options
+     * Controls whether React Query hooks are generated
+     */
+    reactQuery?: {
+        /**
+         * Whether to generate React Query hooks (useQuery, useMutation)
+         * When false, only standalone fetch functions are generated (no React dependency)
+         * @default false
+         */
+        enabled?: boolean;
+    };
     /**
      * Watch mode configuration (dev-only feature)
      * When enabled via CLI --watch flag, the CLI will poll the endpoint for schema changes
@@ -142,7 +154,7 @@ export interface ResolvedWatchConfig {
 /**
  * Resolved configuration with defaults applied
  */
-export interface ResolvedConfig extends Required<Omit<GraphQLSDKConfig, 'headers' | 'tables' | 'queries' | 'mutations' | 'hooks' | 'postgraphile' | 'codegen' | 'orm' | 'watch'>> {
+export interface ResolvedConfig extends Required<Omit<GraphQLSDKConfig, 'headers' | 'tables' | 'queries' | 'mutations' | 'hooks' | 'postgraphile' | 'codegen' | 'orm' | 'reactQuery' | 'watch'>> {
     headers: Record<string, string>;
     tables: {
         include: string[];
@@ -172,6 +184,9 @@ export interface ResolvedConfig extends Required<Omit<GraphQLSDKConfig, 'headers
         output: string;
         useSharedTypes: boolean;
     } | null;
+    reactQuery: {
+        enabled: boolean;
+    };
     watch: ResolvedWatchConfig;
 }
 /**

package/esm/types/config.js

@@ -42,6 +42,9 @@ export const DEFAULT_CONFIG = {
         skipQueryField: true,
     },
     orm: null, // ORM generation disabled by default
+    reactQuery: {
+        enabled: false, // React Query hooks disabled by default
+    },
     watch: DEFAULT_WATCH_CONFIG,
 };
 /**
@@ -96,6 +99,9 @@ export function resolveConfig(config) {
                 useSharedTypes: config.orm.useSharedTypes ?? DEFAULT_ORM_CONFIG.useSharedTypes,
             }
             : null,
+        reactQuery: {
+            enabled: config.reactQuery?.enabled ?? DEFAULT_CONFIG.reactQuery.enabled,
+        },
         watch: {
             pollInterval: config.watch?.pollInterval ?? DEFAULT_WATCH_CONFIG.pollInterval,
             debounce: config.watch?.debounce ?? DEFAULT_WATCH_CONFIG.debounce,

package/esm/types/schema.d.ts

@@ -250,4 +250,6 @@ export interface ResolvedType {
     inputFields?: CleanArgument[];
     /** Values for ENUM types */
     enumValues?: string[];
+    /** Possible types for UNION types */
+    possibleTypes?: string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-codegen",
-  "version": "2.20.1",
+  "version": "2.22.0",
   "description": "CLI-based GraphQL SDK generator for PostGraphile endpoints with React Query hooks",
   "keywords": [
     "graphql",
@@ -41,15 +41,16 @@
     "lint": "eslint . --fix",
     "test": "jest --passWithNoTests",
     "test:watch": "jest --watch",
-    "example:orm": "tsx examples/test-orm.ts",
-    "example:rq": "tsx examples/test-rq.ts",
-    "example:schema": "tsx examples/download-schema.ts"
+    "example:codegen:sdk": "node dist/cli/index.js generate --endpoint http://api.localhost:3000/graphql --output examples/output/generated-sdk",
+    "example:codegen:orm": "node dist/cli/index.js generate-orm --endpoint http://api.localhost:3000/graphql --output examples/output/generated-orm",
+    "example:sdk": "tsx examples/react-query-sdk.ts",
+    "example:orm": "tsx examples/orm-sdk.ts"
   },
   "dependencies": {
     "ajv": "^8.17.1",
     "commander": "^12.1.0",
     "gql-ast": "^2.4.6",
-    "graphql": "15.8.0",
+    "graphql": "15.10.1",
     "inflection": "^3.0.2",
     "jiti": "^2.6.1",
     "prettier": "^3.7.4",
@@ -76,7 +77,8 @@
     "jest": "^29.7.0",
     "react": "^19.2.3",
     "ts-jest": "^29.2.5",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "fc89c642ea6c3e1cd69e47a4151cec1d802520b8"
+  "gitHead": "fe5e59d3a4497d7ac91a051b74e181851393f56c"
 }