@constructive-io/graphql-codegen 2.21.0 → 2.22.0

package/cli/codegen/queries.js

@@ -33,7 +33,7 @@ function generateListQueryHook(table, options = {}) {
     // Collect all filter types used by this table's fields
     const filterTypesUsed = new Set();
     for (const field of scalarFields) {
-        const filterType = (0, utils_1.getScalarFilterType)(field.type.gqlType);
+        const filterType = (0, utils_1.getScalarFilterType)(field.type.gqlType, field.type.isArray);
         if (filterType) {
             filterTypesUsed.add(filterType);
         }
@@ -71,12 +71,14 @@ function generateListQueryHook(table, options = {}) {
     // Generate filter interface
     const fieldFilters = scalarFields
         .map((field) => {
-        const filterType = (0, utils_1.getScalarFilterType)(field.type.gqlType);
+        const filterType = (0, utils_1.getScalarFilterType)(field.type.gqlType, field.type.isArray);
         return filterType ? { fieldName: field.name, filterType } : null;
     })
         .filter((f) => f !== null);
-    sourceFile.addInterface((0, ts_ast_1.createFilterInterface)(filterTypeName, fieldFilters));
+    // Note: Not exported to avoid conflicts with schema-types
+    sourceFile.addInterface((0, ts_ast_1.createFilterInterface)(filterTypeName, fieldFilters, { isExported: false }));
     // Generate OrderBy type
+    // Note: Not exported to avoid conflicts with schema-types
     const orderByValues = [
         ...scalarFields.flatMap((f) => [
             `${(0, utils_1.toScreamingSnake)(f.name)}_ASC`,
@@ -86,7 +88,7 @@ function generateListQueryHook(table, options = {}) {
         'PRIMARY_KEY_ASC',
         'PRIMARY_KEY_DESC',
     ];
-    sourceFile.addTypeAlias((0, ts_ast_1.createTypeAlias)(orderByTypeName, (0, ts_ast_1.createUnionType)(orderByValues)));
+    sourceFile.addTypeAlias((0, ts_ast_1.createTypeAlias)(orderByTypeName, (0, ts_ast_1.createUnionType)(orderByValues), { isExported: false }));
     // Variables interface
     const variablesProps = [
         { name: 'first', type: 'number', optional: true },
@@ -269,6 +271,13 @@ function generateSingleQueryHook(table, options = {}) {
     const { typeName, singularName } = (0, utils_1.getTableNames)(table);
     const hookName = (0, utils_1.getSingleQueryHookName)(table);
     const queryName = (0, utils_1.getSingleRowQueryName)(table);
+    // Get primary key info dynamically from table constraints
+    const pkFields = (0, utils_1.getPrimaryKeyInfo)(table);
+    // For simplicity, use first PK field (most common case)
+    // Composite PKs would need more complex handling
+    const pkField = pkFields[0];
+    const pkName = pkField.name;
+    const pkTsType = pkField.tsType;
     // Generate GraphQL document via AST
     const queryAST = (0, gql_ast_1.buildSingleQueryAST)({ table });
     const queryDocument = (0, gql_ast_1.printGraphQL)(queryAST);
@@ -308,9 +317,9 @@ function generateSingleQueryHook(table, options = {}) {
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Types');
     sourceFile.addStatements('// ============================================================================\n');
-    // Variables interface
+    // Variables interface - use dynamic PK field name and type
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${(0, utils_1.ucFirst)(singularName)}QueryVariables`, [
-        { name: 'id', type: 'string' },
+        { name: pkName, type: pkTsType },
     ]));
     // Result interface
     sourceFile.addInterface((0, ts_ast_1.createInterface)(`${(0, utils_1.ucFirst)(singularName)}QueryResult`, [
@@ -320,20 +329,20 @@ function generateSingleQueryHook(table, options = {}) {
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Query Key');
     sourceFile.addStatements('// ============================================================================\n');
-    // Query key factory
-    sourceFile.addVariableStatement((0, ts_ast_1.createConst)(`${queryName}QueryKey`, `(id: string) =>
-  ['${typeName.toLowerCase()}', 'detail', id] as const`));
+    // Query key factory - use dynamic PK field name and type
+    sourceFile.addVariableStatement((0, ts_ast_1.createConst)(`${queryName}QueryKey`, `(${pkName}: ${pkTsType}) =>
+  ['${typeName.toLowerCase()}', 'detail', ${pkName}] as const`));
     // Add React Query hook section (only if enabled)
     if (reactQueryEnabled) {
         sourceFile.addStatements('\n// ============================================================================');
         sourceFile.addStatements('// Hook');
         sourceFile.addStatements('// ============================================================================\n');
-        // Hook function
+        // Hook function - use dynamic PK field name and type
         sourceFile.addFunction({
             name: hookName,
             isExported: true,
             parameters: [
-                { name: 'id', type: 'string' },
+                { name: pkName, type: pkTsType },
                 {
                     name: 'options',
                     type: `Omit<UseQueryOptions<${(0, utils_1.ucFirst)(singularName)}QueryResult, Error>, 'queryKey' | 'queryFn'>`,
@@ -341,24 +350,24 @@ function generateSingleQueryHook(table, options = {}) {
                 },
             ],
             statements: `return useQuery({
-    queryKey: ${queryName}QueryKey(id),
+    queryKey: ${queryName}QueryKey(${pkName}),
     queryFn: () => execute<${(0, utils_1.ucFirst)(singularName)}QueryResult, ${(0, utils_1.ucFirst)(singularName)}QueryVariables>(
       ${queryName}QueryDocument,
-      { id }
+      { ${pkName} }
     ),
-    enabled: !!id && (options?.enabled !== false),
+    enabled: !!${pkName} && (options?.enabled !== false),
     ...options,
   });`,
             docs: [
                 {
-                    description: `Query hook for fetching a single ${typeName} by ID
+                    description: `Query hook for fetching a single ${typeName} by primary key
 
 @example
 \`\`\`tsx
-const { data, isLoading } = ${hookName}('uuid-here');
+const { data, isLoading } = ${hookName}(${pkTsType === 'string' ? "'value-here'" : '123'});
 
 if (data?.${queryName}) {
-  console.log(data.${queryName}.id);
+  console.log(data.${queryName}.${pkName});
 }
 \`\`\``,
                 },
@@ -369,13 +378,13 @@ if (data?.${queryName}) {
     sourceFile.addStatements('\n// ============================================================================');
     sourceFile.addStatements('// Standalone Functions (non-React)');
     sourceFile.addStatements('// ============================================================================\n');
-    // Fetch function (standalone, no React)
+    // Fetch function (standalone, no React) - use dynamic PK
     sourceFile.addFunction({
         name: `fetch${(0, utils_1.ucFirst)(singularName)}Query`,
         isExported: true,
         isAsync: true,
         parameters: [
-            { name: 'id', type: 'string' },
+            { name: pkName, type: pkTsType },
             {
                 name: 'options',
                 type: 'ExecuteOptions',
@@ -385,21 +394,21 @@ if (data?.${queryName}) {
         returnType: `Promise<${(0, utils_1.ucFirst)(singularName)}QueryResult>`,
         statements: `return execute<${(0, utils_1.ucFirst)(singularName)}QueryResult, ${(0, utils_1.ucFirst)(singularName)}QueryVariables>(
     ${queryName}QueryDocument,
-    { id },
+    { ${pkName} },
     options
   );`,
         docs: [
             {
-                description: `Fetch a single ${typeName} by ID without React hooks
+                description: `Fetch a single ${typeName} by primary key without React hooks
 
 @example
 \`\`\`ts
-const data = await fetch${(0, utils_1.ucFirst)(singularName)}Query('uuid-here');
+const data = await fetch${(0, utils_1.ucFirst)(singularName)}Query(${pkTsType === 'string' ? "'value-here'" : '123'});
 \`\`\``,
             },
         ],
     });
-    // Prefetch function (for SSR/QueryClient) - only if React Query is enabled
+    // Prefetch function (for SSR/QueryClient) - only if React Query is enabled, use dynamic PK
     if (reactQueryEnabled) {
         sourceFile.addFunction({
             name: `prefetch${(0, utils_1.ucFirst)(singularName)}Query`,
@@ -407,7 +416,7 @@ const data = await fetch${(0, utils_1.ucFirst)(singularName)}Query('uuid-here');
             isAsync: true,
             parameters: [
                 { name: 'queryClient', type: 'QueryClient' },
-                { name: 'id', type: 'string' },
+                { name: pkName, type: pkTsType },
                 {
                     name: 'options',
                     type: 'ExecuteOptions',
@@ -416,10 +425,10 @@ const data = await fetch${(0, utils_1.ucFirst)(singularName)}Query('uuid-here');
             ],
             returnType: 'Promise<void>',
             statements: `await queryClient.prefetchQuery({
-    queryKey: ${queryName}QueryKey(id),
+    queryKey: ${queryName}QueryKey(${pkName}),
     queryFn: () => execute<${(0, utils_1.ucFirst)(singularName)}QueryResult, ${(0, utils_1.ucFirst)(singularName)}QueryVariables>(
       ${queryName}QueryDocument,
-      { id },
+      { ${pkName} },
       options
     ),
   });`,
@@ -429,7 +438,7 @@ const data = await fetch${(0, utils_1.ucFirst)(singularName)}Query('uuid-here');
 
 @example
 \`\`\`ts
-await prefetch${(0, utils_1.ucFirst)(singularName)}Query(queryClient, 'uuid-here');
+await prefetch${(0, utils_1.ucFirst)(singularName)}Query(queryClient, ${pkTsType === 'string' ? "'value-here'" : '123'});
 \`\`\``,
                 },
             ],

package/cli/codegen/scalars.d.ts

@@ -4,9 +4,11 @@
 export declare const SCALAR_TS_MAP: Record<string, string>;
 export declare const SCALAR_FILTER_MAP: Record<string, string>;
 export declare const SCALAR_NAMES: Set<string>;
-export interface ScalarToTsOptions {
+/** All base filter type names - skip these in schema-types.ts to avoid duplicates */
+export declare const BASE_FILTER_TYPE_NAMES: Set<string>;
+export declare function scalarToTsType(scalarName: string, options?: {
     unknownScalar?: 'unknown' | 'name';
     overrides?: Record<string, string>;
-}
-export declare function scalarToTsType(scalarName: string, options?: ScalarToTsOptions): string;
-export declare function scalarToFilterType(scalarName: string): string | null;
+}): string;
+/** Get the filter type for a scalar (handles both scalar and array types) */
+export declare function scalarToFilterType(scalarName: string, isArray?: boolean): string | null;

package/cli/codegen/scalars.js

@@ -3,7 +3,7 @@
  * Shared scalar mappings for code generation
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SCALAR_NAMES = exports.SCALAR_FILTER_MAP = exports.SCALAR_TS_MAP = void 0;
+exports.BASE_FILTER_TYPE_NAMES = exports.SCALAR_NAMES = exports.SCALAR_FILTER_MAP = exports.SCALAR_TS_MAP = void 0;
 exports.scalarToTsType = scalarToTsType;
 exports.scalarToFilterType = scalarToFilterType;
 exports.SCALAR_TS_MAP = {
@@ -37,6 +37,8 @@ exports.SCALAR_TS_MAP = {
     MacAddr: 'string',
     TsVector: 'string',
     TsQuery: 'string',
+    // File upload
+    Upload: 'File',
 };
 exports.SCALAR_FILTER_MAP = {
     String: 'StringFilter',
@@ -57,15 +59,21 @@ exports.SCALAR_FILTER_MAP = {
     Interval: 'StringFilter',
 };
 exports.SCALAR_NAMES = new Set(Object.keys(exports.SCALAR_TS_MAP));
+/** Scalars that have list filter variants (e.g., StringListFilter) */
+const LIST_FILTER_SCALARS = new Set(['String', 'Int', 'UUID']);
+/** All base filter type names - skip these in schema-types.ts to avoid duplicates */
+exports.BASE_FILTER_TYPE_NAMES = new Set([
+    ...new Set(Object.values(exports.SCALAR_FILTER_MAP)),
+    ...Array.from(LIST_FILTER_SCALARS).map((s) => `${s}ListFilter`),
+]);
 function scalarToTsType(scalarName, options = {}) {
-    const override = options.overrides?.[scalarName];
-    if (override)
-        return override;
-    const mapped = exports.SCALAR_TS_MAP[scalarName];
-    if (mapped)
-        return mapped;
-    return options.unknownScalar === 'unknown' ? 'unknown' : scalarName;
+    return options.overrides?.[scalarName] ?? exports.SCALAR_TS_MAP[scalarName] ?? (options.unknownScalar === 'unknown' ? 'unknown' : scalarName);
 }
-function scalarToFilterType(scalarName) {
+/** Get the filter type for a scalar (handles both scalar and array types) */
+function scalarToFilterType(scalarName, isArray = false) {
+    const baseName = scalarName === 'ID' ? 'UUID' : scalarName;
+    if (isArray) {
+        return LIST_FILTER_SCALARS.has(baseName) ? `${baseName}ListFilter` : null;
+    }
     return exports.SCALAR_FILTER_MAP[scalarName] ?? null;
 }

package/cli/codegen/schema-types-generator.d.ts

@@ -0,0 +1,26 @@
+import type { TypeRegistry } from '../../types/schema';
+export interface GeneratedSchemaTypesFile {
+    fileName: string;
+    content: string;
+    /** List of enum type names that were generated */
+    generatedEnums: string[];
+    /** List of table entity types that are referenced */
+    referencedTableTypes: string[];
+}
+export interface GenerateSchemaTypesOptions {
+    /** The TypeRegistry containing all GraphQL types */
+    typeRegistry: TypeRegistry;
+    /** Type names that already exist in types.ts (table entity types) */
+    tableTypeNames: Set<string>;
+}
+export interface PayloadTypesResult {
+    generatedTypes: Set<string>;
+    referencedTableTypes: Set<string>;
+}
+/**
+ * Generate comprehensive schema-types.ts file using ts-morph AST
+ *
+ * This generates all Input/Payload/Enum types from the TypeRegistry
+ * that are needed by custom mutation/query hooks.
+ */
+export declare function generateSchemaTypesFile(options: GenerateSchemaTypesOptions): GeneratedSchemaTypesFile;

package/cli/codegen/schema-types-generator.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaTypesFile = generateSchemaTypesFile;
+const ts_ast_1 = require("./ts-ast");
+const type_resolver_1 = require("./type-resolver");
+const scalars_1 = require("./scalars");
+// ============================================================================
+// Constants
+// ============================================================================
+/**
+ * Types that should not be generated (scalars, built-ins, types generated elsewhere)
+ */
+const SKIP_TYPES = new Set([
+    ...scalars_1.SCALAR_NAMES,
+    // GraphQL built-ins
+    'Query',
+    'Mutation',
+    'Subscription',
+    '__Schema',
+    '__Type',
+    '__Field',
+    '__InputValue',
+    '__EnumValue',
+    '__Directive',
+    // Note: PageInfo and Cursor are NOT skipped - they're needed by Connection types
+    // Base filter types (generated in types.ts via filters.ts)
+    ...scalars_1.BASE_FILTER_TYPE_NAMES,
+]);
+/**
+ * Type name patterns to skip (regex patterns)
+ *
+ * Note: We intentionally DO NOT skip Connection, Edge, Filter, or Patch types
+ * because they may be referenced by custom operations or payload types.
+ * Only skip Condition and OrderBy which are typically not needed.
+ */
+const SKIP_TYPE_PATTERNS = [
+    /Condition$/, // e.g., UserCondition (filter conditions are separate)
+    /OrderBy$/, // e.g., UsersOrderBy (ordering is handled separately)
+];
+// ============================================================================
+// Type Conversion Utilities
+// ============================================================================
+/**
+ * Convert a CleanTypeRef to TypeScript type string
+ */
+function typeRefToTs(typeRef) {
+    if (typeRef.kind === 'NON_NULL') {
+        if (typeRef.ofType) {
+            return typeRefToTs(typeRef.ofType);
+        }
+        return typeRef.name ?? 'unknown';
+    }
+    if (typeRef.kind === 'LIST') {
+        if (typeRef.ofType) {
+            return `${typeRefToTs(typeRef.ofType)}[]`;
+        }
+        return 'unknown[]';
+    }
+    // Scalar or named type
+    const name = typeRef.name ?? 'unknown';
+    return (0, scalars_1.scalarToTsType)(name, { unknownScalar: 'name' });
+}
+/**
+ * Check if a type is required (NON_NULL)
+ */
+function isRequired(typeRef) {
+    return typeRef.kind === 'NON_NULL';
+}
+/**
+ * Check if a type should be skipped
+ */
+function shouldSkipType(typeName, tableTypeNames) {
+    // Skip scalars and built-ins
+    if (SKIP_TYPES.has(typeName))
+        return true;
+    // Skip table entity types (already in types.ts)
+    if (tableTypeNames.has(typeName))
+        return true;
+    // Skip types matching patterns
+    for (const pattern of SKIP_TYPE_PATTERNS) {
+        if (pattern.test(typeName))
+            return true;
+    }
+    // Skip table-specific types that would conflict with inline types in table-based hooks.
+    // Note: Patch and CreateInput are now NOT exported from hooks (isExported: false),
+    // so we only skip Filter types here.
+    // The Filter and OrderBy types are generated inline (non-exported) by table query hooks,
+    // but schema-types should still generate them for custom operations that need them.
+    // Actually, we don't skip any table-based types now since hooks don't export them.
+    return false;
+}
+// ============================================================================
+// ENUM Types Generator
+// ============================================================================
+/**
+ * Add ENUM types to source file
+ */
+function addEnumTypes(sourceFile, typeRegistry, tableTypeNames) {
+    const generatedTypes = new Set();
+    (0, ts_ast_1.addSectionComment)(sourceFile, 'Enum Types');
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'ENUM')
+            continue;
+        if (shouldSkipType(typeName, tableTypeNames))
+            continue;
+        if (!typeInfo.enumValues || typeInfo.enumValues.length === 0)
+            continue;
+        const values = typeInfo.enumValues.map((v) => `'${v}'`).join(' | ');
+        sourceFile.addTypeAlias((0, ts_ast_1.createTypeAlias)(typeName, values));
+        generatedTypes.add(typeName);
+    }
+    return generatedTypes;
+}
+// ============================================================================
+// INPUT_OBJECT Types Generator
+// ============================================================================
+/**
+ * Add INPUT_OBJECT types to source file
+ * Uses iteration to handle nested input types
+ */
+function addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+    const generatedTypes = new Set(alreadyGenerated);
+    const typesToGenerate = new Set();
+    // Collect all INPUT_OBJECT types
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'INPUT_OBJECT')
+            continue;
+        if (shouldSkipType(typeName, tableTypeNames))
+            continue;
+        if (generatedTypes.has(typeName))
+            continue;
+        typesToGenerate.add(typeName);
+    }
+    if (typesToGenerate.size === 0)
+        return generatedTypes;
+    (0, ts_ast_1.addSectionComment)(sourceFile, 'Input Object Types');
+    // Process all types - no artificial limit
+    while (typesToGenerate.size > 0) {
+        const typeNameResult = typesToGenerate.values().next();
+        if (typeNameResult.done)
+            break;
+        const typeName = typeNameResult.value;
+        typesToGenerate.delete(typeName);
+        if (generatedTypes.has(typeName))
+            continue;
+        const typeInfo = typeRegistry.get(typeName);
+        if (!typeInfo || typeInfo.kind !== 'INPUT_OBJECT')
+            continue;
+        generatedTypes.add(typeName);
+        if (typeInfo.inputFields && typeInfo.inputFields.length > 0) {
+            const properties = [];
+            for (const field of typeInfo.inputFields) {
+                const optional = !isRequired(field.type);
+                const tsType = typeRefToTs(field.type);
+                properties.push({
+                    name: field.name,
+                    type: tsType,
+                    optional,
+                    docs: field.description ? [field.description] : undefined,
+                });
+                // Follow nested Input types
+                const baseType = (0, type_resolver_1.getTypeBaseName)(field.type);
+                if (baseType &&
+                    !generatedTypes.has(baseType) &&
+                    !shouldSkipType(baseType, tableTypeNames)) {
+                    const nestedType = typeRegistry.get(baseType);
+                    if (nestedType?.kind === 'INPUT_OBJECT') {
+                        typesToGenerate.add(baseType);
+                    }
+                }
+            }
+            sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, properties));
+        }
+        else {
+            // Empty input object
+            sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, []));
+        }
+    }
+    return generatedTypes;
+}
+// ============================================================================
+// UNION Types Generator
+// ============================================================================
+/**
+ * Add UNION types to source file
+ */
+function addUnionTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+    const generatedTypes = new Set(alreadyGenerated);
+    const unionTypesToGenerate = new Set();
+    // Collect all UNION types
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'UNION')
+            continue;
+        if (shouldSkipType(typeName, tableTypeNames))
+            continue;
+        if (generatedTypes.has(typeName))
+            continue;
+        unionTypesToGenerate.add(typeName);
+    }
+    if (unionTypesToGenerate.size === 0)
+        return generatedTypes;
+    (0, ts_ast_1.addSectionComment)(sourceFile, 'Union Types');
+    for (const typeName of unionTypesToGenerate) {
+        const typeInfo = typeRegistry.get(typeName);
+        if (!typeInfo || typeInfo.kind !== 'UNION')
+            continue;
+        if (!typeInfo.possibleTypes || typeInfo.possibleTypes.length === 0)
+            continue;
+        // Generate union type as TypeScript union
+        const unionMembers = typeInfo.possibleTypes.join(' | ');
+        sourceFile.addTypeAlias((0, ts_ast_1.createTypeAlias)(typeName, unionMembers));
+        generatedTypes.add(typeName);
+    }
+    return generatedTypes;
+}
+/**
+ * Collect return types from Query and Mutation root types
+ * This dynamically discovers what OBJECT types need to be generated
+ * based on actual schema structure, not pattern matching
+ */
+function collectReturnTypesFromRootTypes(typeRegistry, tableTypeNames) {
+    const returnTypes = new Set();
+    // Get Query and Mutation root types
+    const queryType = typeRegistry.get('Query');
+    const mutationType = typeRegistry.get('Mutation');
+    const processFields = (fields) => {
+        if (!fields)
+            return;
+        for (const field of fields) {
+            const baseType = (0, type_resolver_1.getTypeBaseName)(field.type);
+            if (baseType && !shouldSkipType(baseType, tableTypeNames)) {
+                const typeInfo = typeRegistry.get(baseType);
+                if (typeInfo?.kind === 'OBJECT') {
+                    returnTypes.add(baseType);
+                }
+            }
+        }
+    };
+    if (queryType?.fields)
+        processFields(queryType.fields);
+    if (mutationType?.fields)
+        processFields(mutationType.fields);
+    return returnTypes;
+}
+/**
+ * Add Payload OBJECT types to source file
+ * These are return types from mutations (e.g., LoginPayload, BootstrapUserPayload)
+ *
+ * Also tracks which table entity types are referenced so they can be imported.
+ *
+ * Uses dynamic type discovery from Query/Mutation return types instead of pattern matching.
+ */
+function addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, alreadyGenerated) {
+    const generatedTypes = new Set(alreadyGenerated);
+    const referencedTableTypes = new Set();
+    // Dynamically collect return types from Query and Mutation
+    const typesToGenerate = collectReturnTypesFromRootTypes(typeRegistry, tableTypeNames);
+    // Filter out already generated types
+    for (const typeName of Array.from(typesToGenerate)) {
+        if (generatedTypes.has(typeName)) {
+            typesToGenerate.delete(typeName);
+        }
+    }
+    if (typesToGenerate.size === 0) {
+        return { generatedTypes, referencedTableTypes };
+    }
+    (0, ts_ast_1.addSectionComment)(sourceFile, 'Payload/Return Object Types');
+    // Process all types - no artificial limit
+    while (typesToGenerate.size > 0) {
+        const typeNameResult = typesToGenerate.values().next();
+        if (typeNameResult.done)
+            break;
+        const typeName = typeNameResult.value;
+        typesToGenerate.delete(typeName);
+        if (generatedTypes.has(typeName))
+            continue;
+        const typeInfo = typeRegistry.get(typeName);
+        if (!typeInfo || typeInfo.kind !== 'OBJECT')
+            continue;
+        generatedTypes.add(typeName);
+        if (typeInfo.fields && typeInfo.fields.length > 0) {
+            const properties = [];
+            for (const field of typeInfo.fields) {
+                const baseType = (0, type_resolver_1.getTypeBaseName)(field.type);
+                // Skip Query and Mutation fields
+                if (baseType === 'Query' || baseType === 'Mutation')
+                    continue;
+                const tsType = typeRefToTs(field.type);
+                const isNullable = !isRequired(field.type);
+                properties.push({
+                    name: field.name,
+                    type: isNullable ? `${tsType} | null` : tsType,
+                    optional: isNullable,
+                    docs: field.description ? [field.description] : undefined,
+                });
+                // Track table entity types that are referenced
+                if (baseType && tableTypeNames.has(baseType)) {
+                    referencedTableTypes.add(baseType);
+                }
+                // Follow nested OBJECT types that aren't table types
+                if (baseType &&
+                    !generatedTypes.has(baseType) &&
+                    !shouldSkipType(baseType, tableTypeNames)) {
+                    const nestedType = typeRegistry.get(baseType);
+                    if (nestedType?.kind === 'OBJECT') {
+                        typesToGenerate.add(baseType);
+                    }
+                }
+            }
+            sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, properties));
+        }
+        else {
+            // Empty payload object
+            sourceFile.addInterface((0, ts_ast_1.createInterface)(typeName, []));
+        }
+    }
+    return { generatedTypes, referencedTableTypes };
+}
+// ============================================================================
+// Main Generator
+// ============================================================================
+/**
+ * Generate comprehensive schema-types.ts file using ts-morph AST
+ *
+ * This generates all Input/Payload/Enum types from the TypeRegistry
+ * that are needed by custom mutation/query hooks.
+ */
+function generateSchemaTypesFile(options) {
+    const { typeRegistry, tableTypeNames } = options;
+    const project = (0, ts_ast_1.createProject)();
+    const sourceFile = (0, ts_ast_1.createSourceFile)(project, 'schema-types.ts');
+    // Add file header
+    sourceFile.insertText(0, (0, ts_ast_1.createFileHeader)('GraphQL schema types for custom operations') + '\n');
+    // Track all generated types
+    let generatedTypes = new Set();
+    // 1. Generate ENUM types
+    const enumTypes = addEnumTypes(sourceFile, typeRegistry, tableTypeNames);
+    generatedTypes = new Set([...generatedTypes, ...enumTypes]);
+    // 2. Generate UNION types
+    const unionTypes = addUnionTypes(sourceFile, typeRegistry, tableTypeNames, generatedTypes);
+    generatedTypes = new Set([...generatedTypes, ...unionTypes]);
+    // 3. Generate INPUT_OBJECT types
+    const inputTypes = addInputObjectTypes(sourceFile, typeRegistry, tableTypeNames, generatedTypes);
+    generatedTypes = new Set([...generatedTypes, ...inputTypes]);
+    // 4. Generate Payload OBJECT types
+    const payloadResult = addPayloadObjectTypes(sourceFile, typeRegistry, tableTypeNames, generatedTypes);
+    // 5. Add imports from types.ts (table entity types + base filter types)
+    const referencedTableTypes = Array.from(payloadResult.referencedTableTypes).sort();
+    // Always import base filter types since generated Filter interfaces reference them
+    const baseFilterImports = Array.from(scalars_1.BASE_FILTER_TYPE_NAMES).sort();
+    const allTypesImports = [...referencedTableTypes, ...baseFilterImports];
+    if (allTypesImports.length > 0) {
+        // Insert import after the file header comment
+        const importStatement = `import type { ${allTypesImports.join(', ')} } from './types';\n\n`;
+        // Find position after header (after first */ + newlines)
+        const headerEndIndex = sourceFile.getFullText().indexOf('*/') + 3;
+        sourceFile.insertText(headerEndIndex, '\n' + importStatement);
+    }
+    return {
+        fileName: 'schema-types.ts',
+        content: (0, ts_ast_1.getMinimalFormattedOutput)(sourceFile),
+        generatedEnums: Array.from(enumTypes).sort(),
+        referencedTableTypes,
+    };
+}

package/cli/codegen/ts-ast.d.ts

@@ -66,7 +66,9 @@ export declare function createInterface(name: string, properties: InterfacePrope
 export declare function createFilterInterface(name: string, fieldFilters: Array<{
     fieldName: string;
     filterType: string;
-}>): InterfaceDeclarationStructure;
+}>, options?: {
+    isExported?: boolean;
+}): InterfaceDeclarationStructure;
 /**
  * Create type alias declaration structure
  */

package/cli/codegen/ts-ast.js

@@ -163,7 +163,7 @@ function createInterface(name, properties, options) {
 /**
  * Create filter interface with standard PostGraphile operators
  */
-function createFilterInterface(name, fieldFilters) {
+function createFilterInterface(name, fieldFilters, options) {
     const properties = [
         ...fieldFilters.map((f) => ({
             name: f.fieldName,
@@ -174,7 +174,7 @@ function createFilterInterface(name, fieldFilters) {
         { name: 'or', type: `${name}[]`, optional: true, docs: ['Logical OR'] },
         { name: 'not', type: name, optional: true, docs: ['Logical NOT'] },
     ];
-    return createInterface(name, properties);
+    return createInterface(name, properties, { isExported: options?.isExported ?? true });
 }
 // ============================================================================
 // Type alias builders