@constructive-io/graphql-codegen 3.3.2 → 4.0.0

package/core/codegen/orm/select-types.d.ts

@@ -44,25 +44,27 @@ export interface NestedSelectConfig {
     filter?: Record<string, unknown>;
     orderBy?: string[];
 }
+type DepthLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type DecrementDepth = {
+    0: 0;
+    1: 0;
+    2: 1;
+    3: 2;
+    4: 3;
+    5: 4;
+    6: 5;
+    7: 6;
+    8: 7;
+    9: 8;
+    10: 9;
+};
 /**
  * Recursively validates select objects, rejecting unknown keys.
  *
- * NOTE: This type is intentionally NOT used in generated parameter positions
- * (conditional types block IDE autocompletion). Parameters use `S` directly
- * with `S extends XxxSelect` constraints, which provides full
- * autocompletion via TypeScript's contextual typing.
- *
- * @example
- * // This will cause a type error because 'invalid' doesn't exist:
- * type Result = DeepExact<{ id: true, invalid: true }, { id?: boolean }>;
- * // Result = never (causes assignment error)
- *
- * @example
- * // This works because all fields are valid:
- * type Result = DeepExact<{ id: true }, { id?: boolean; name?: boolean }>;
- * // Result = { id: true }
+ * NOTE: Depth is intentionally capped to avoid circular-instantiation issues
+ * in very large cyclic schemas.
  */
-export type DeepExact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? {
+export type DeepExact<T, Shape, Depth extends DepthLevel = 10> = Depth extends 0 ? T extends Shape ? T : never : T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? {
     [K in keyof T]: K extends keyof Shape ? T[K] extends {
         select: infer NS;
     } ? Extract<Shape[K], {
@@ -70,10 +72,10 @@ export type DeepExact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape
     }> extends {
         select?: infer ShapeNS;
     } ? DeepExact<Omit<T[K], 'select'> & {
-        select: DeepExact<NS, NonNullable<ShapeNS>>;
+        select: DeepExact<NS, NonNullable<ShapeNS>, DecrementDepth[Depth]>;
     }, Extract<Shape[K], {
         select?: unknown;
-    }>> : never : T[K] : never;
+    }>, DecrementDepth[Depth]> : never : T[K] : never;
 } : never : never;
 /**
  * Enforces exact select shape while keeping contextual typing on `S extends XxxSelect`.
@@ -81,6 +83,13 @@ export type DeepExact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape
  * `{ select: S } & StrictSelect<S, XxxSelect>`.
  */
 export type StrictSelect<S, Shape> = S extends DeepExact<S, Shape> ? {} : never;
+/**
+ * Hook-optimized strict select variant.
+ *
+ * Uses a shallower recursion depth to keep editor autocomplete responsive
+ * in large schemas while still validating common nested-select mistakes.
+ */
+export type HookStrictSelect<S, Shape> = S extends DeepExact<S, Shape, 5> ? {} : never;
 /**
  * Infers the result type from a select configuration
  *
@@ -205,3 +214,4 @@ export type MutationResult<TEntity, TSelect, TPayloadKey extends string> = Query
         [EntityKey: string]: ResolveSelectResult<TEntity, TSelect>;
     };
 }>;
+export {};

package/core/codegen/queries.js

@@ -76,7 +76,12 @@ function generateListQueryHook(table, options = {}) {
         }
     }
     statements.push((0, hooks_ast_1.createImportDeclaration)('../../orm/input-types', [selectTypeName, relationTypeName, filterTypeName, orderByTypeName], true));
-    statements.push((0, hooks_ast_1.createImportDeclaration)('../../orm/select-types', ['FindManyArgs', 'InferSelectResult', 'ConnectionResult', 'StrictSelect'], true));
+    statements.push((0, hooks_ast_1.createImportDeclaration)('../../orm/select-types', [
+        'FindManyArgs',
+        'InferSelectResult',
+        'ConnectionResult',
+        'HookStrictSelect',
+    ], true));
     // Re-exports
     statements.push((0, hooks_ast_1.createTypeReExport)([selectTypeName, relationTypeName, filterTypeName, orderByTypeName], '../../orm/input-types'));
     // Query key
@@ -193,8 +198,10 @@ function generateListQueryHook(table, options = {}) {
     const fetchFnName = `fetch${(0, utils_1.ucFirst)(pluralName)}Query`;
     {
         // Overload 1: with fields
-        const f1ParamType = t.tsTypeLiteral([
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsListSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName, filterTypeName, orderByTypeName))),
+        const f1ParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsListSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName, filterTypeName, orderByTypeName))),
+            ]),
         ]);
         const f1Decl = (0, hooks_ast_1.exportAsyncDeclareFunction)(fetchFnName, (0, hooks_ast_1.createSTypeParam)(selectTypeName), [(0, hooks_ast_1.createFunctionParam)('params', f1ParamType)], (0, hooks_ast_1.typeRef)('Promise', [listResultTypeAST((0, hooks_ast_1.sRef)())]));
         (0, hooks_ast_1.addJSDocComment)(f1Decl, [
@@ -224,15 +231,17 @@ function generateListQueryHook(table, options = {}) {
     if (reactQueryEnabled) {
         const prefetchFnName = `prefetch${(0, utils_1.ucFirst)(pluralName)}Query`;
         // Overload 1: with fields
-        const p1Params = [
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsListSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName, filterTypeName, orderByTypeName))),
-        ];
+        const p1BaseParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsListSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName, filterTypeName, orderByTypeName))),
+            ]),
+        ]);
         const p1ParamType = hasRelationships && useCentralizedKeys
             ? t.tsIntersectionType([
-                t.tsTypeLiteral(p1Params),
+                p1BaseParamType,
                 (0, hooks_ast_1.scopeTypeLiteral)(scopeTypeName),
             ])
-            : t.tsTypeLiteral(p1Params);
+            : p1BaseParamType;
         const p1Decl = (0, hooks_ast_1.exportAsyncDeclareFunction)(prefetchFnName, (0, hooks_ast_1.createSTypeParam)(selectTypeName), [
             (0, hooks_ast_1.createFunctionParam)('queryClient', (0, hooks_ast_1.typeRef)('QueryClient')),
             (0, hooks_ast_1.createFunctionParam)('params', p1ParamType),
@@ -315,7 +324,7 @@ function generateSingleQueryHook(table, options = {}) {
         }
     }
     statements.push((0, hooks_ast_1.createImportDeclaration)('../../orm/input-types', [selectTypeName, relationTypeName], true));
-    statements.push((0, hooks_ast_1.createImportDeclaration)('../../orm/select-types', ['InferSelectResult', 'StrictSelect'], true));
+    statements.push((0, hooks_ast_1.createImportDeclaration)('../../orm/select-types', ['InferSelectResult', 'HookStrictSelect'], true));
     // Re-exports
     statements.push((0, hooks_ast_1.createTypeReExport)([selectTypeName, relationTypeName], '../../orm/input-types'));
     // Query key
@@ -383,12 +392,11 @@ function generateSingleQueryHook(table, options = {}) {
             docLines.push('```');
         }
         // Overload 1: with fields
-        const o1Props = [
-            t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName))),
-        ];
         const o1ParamType = t.tsIntersectionType([
-            t.tsTypeLiteral(o1Props),
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName))),
+            ]),
             buildSingleOptionsType(singleResultTypeAST((0, hooks_ast_1.sRef)()), (0, hooks_ast_1.typeRef)('TData')),
         ]);
         const o1 = (0, hooks_ast_1.exportDeclareFunction)(hookName, (0, hooks_ast_1.createSAndTDataTypeParams)(selectTypeName, singleResultTypeAST((0, hooks_ast_1.sRef)())), [(0, hooks_ast_1.createFunctionParam)('params', o1ParamType)], (0, hooks_ast_1.typeRef)('UseQueryResult', [(0, hooks_ast_1.typeRef)('TData')]));
@@ -431,11 +439,13 @@ function generateSingleQueryHook(table, options = {}) {
     const fetchFnName = `fetch${(0, utils_1.ucFirst)(singularName)}Query`;
     {
         // Overload 1: with fields
-        const f1Props = [
-            t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName))),
-        ];
-        const f1Decl = (0, hooks_ast_1.exportAsyncDeclareFunction)(fetchFnName, (0, hooks_ast_1.createSTypeParam)(selectTypeName), [(0, hooks_ast_1.createFunctionParam)('params', t.tsTypeLiteral(f1Props))], (0, hooks_ast_1.typeRef)('Promise', [singleResultTypeAST((0, hooks_ast_1.sRef)())]));
+        const f1ParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName))),
+            ]),
+        ]);
+        const f1Decl = (0, hooks_ast_1.exportAsyncDeclareFunction)(fetchFnName, (0, hooks_ast_1.createSTypeParam)(selectTypeName), [(0, hooks_ast_1.createFunctionParam)('params', f1ParamType)], (0, hooks_ast_1.typeRef)('Promise', [singleResultTypeAST((0, hooks_ast_1.sRef)())]));
         (0, hooks_ast_1.addJSDocComment)(f1Decl, [
             `Fetch a single ${typeName} without React hooks`,
             '',
@@ -462,16 +472,18 @@ function generateSingleQueryHook(table, options = {}) {
     if (reactQueryEnabled) {
         const prefetchFnName = `prefetch${(0, utils_1.ucFirst)(singularName)}Query`;
         // Overload 1: with fields
-        const p1Props = [
-            t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName))),
-        ];
+        const p1BaseParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation((0, hooks_ast_1.withFieldsSelectionType)((0, hooks_ast_1.sRef)(), selectTypeName))),
+            ]),
+        ]);
         const p1ParamType = hasRelationships && useCentralizedKeys
             ? t.tsIntersectionType([
-                t.tsTypeLiteral(p1Props),
+                p1BaseParamType,
                 (0, hooks_ast_1.scopeTypeLiteral)(scopeTypeName),
             ])
-            : t.tsTypeLiteral(p1Props);
+            : p1BaseParamType;
         const p1Decl = (0, hooks_ast_1.exportAsyncDeclareFunction)(prefetchFnName, (0, hooks_ast_1.createSTypeParam)(selectTypeName), [
             (0, hooks_ast_1.createFunctionParam)('queryClient', (0, hooks_ast_1.typeRef)('QueryClient')),
             (0, hooks_ast_1.createFunctionParam)('params', p1ParamType),

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

@@ -96,6 +96,25 @@ function shouldSkipType(typeName, tableTypeNames) {
     }
     return false;
 }
+function collectCustomScalarTypes(typeRegistry) {
+    const customScalarTypes = new Set();
+    for (const [typeName, typeInfo] of typeRegistry) {
+        if (typeInfo.kind !== 'SCALAR')
+            continue;
+        if (scalars_1.SCALAR_NAMES.has(typeName))
+            continue;
+        customScalarTypes.add(typeName);
+    }
+    return Array.from(customScalarTypes).sort();
+}
+function generateCustomScalarTypes(customScalarTypes) {
+    const statements = [];
+    for (const scalarType of customScalarTypes) {
+        const alias = t.tsTypeAliasDeclaration(t.identifier(scalarType), null, t.tsUnknownKeyword());
+        statements.push(t.exportNamedDeclaration(alias));
+    }
+    return statements;
+}
 function generateEnumTypes(typeRegistry, tableTypeNames) {
     const statements = [];
     const generatedTypes = new Set();
@@ -260,6 +279,7 @@ function generateSchemaTypesFile(options) {
     const { typeRegistry, tableTypeNames } = options;
     const allStatements = [];
     let generatedTypes = new Set();
+    const customScalarTypes = collectCustomScalarTypes(typeRegistry);
     const enumResult = generateEnumTypes(typeRegistry, tableTypeNames);
     generatedTypes = new Set([...generatedTypes, ...enumResult.generatedTypes]);
     const unionResult = generateUnionTypes(typeRegistry, tableTypeNames, generatedTypes);
@@ -275,6 +295,7 @@ function generateSchemaTypesFile(options) {
         typesImport.importKind = 'type';
         allStatements.push(typesImport);
     }
+    allStatements.push(...generateCustomScalarTypes(customScalarTypes));
     allStatements.push(...enumResult.statements);
     allStatements.push(...unionResult.statements);
     allStatements.push(...inputResult.statements);

package/core/codegen/templates/hooks-selection.ts

@@ -27,9 +27,20 @@ export interface ListSelectionConfig<
   offset?: number;
 }
 
+function ensureSelectionFields(
+  selection: SelectionConfig<unknown> | undefined,
+): asserts selection is SelectionConfig<unknown> {
+  if (!selection || typeof selection !== 'object' || !('fields' in selection)) {
+    throw new Error(
+      'Invalid hook params: `selection.fields` is required. Example: { selection: { fields: { id: true } } }',
+    );
+  }
+}
+
 export function buildSelectionArgs<TFields>(
   selection: SelectionConfig<TFields>,
 ): { select: TFields } {
+  ensureSelectionFields(selection);
   return { select: selection.fields };
 }
 
@@ -45,6 +56,7 @@ export function buildListSelectionArgs<TFields, TWhere, TOrderBy>(
   before?: string;
   offset?: number;
 } {
+  ensureSelectionFields(selection);
   return {
     select: selection.fields,
     where: selection.where,

package/core/codegen/templates/query-builder.ts

@@ -19,19 +19,20 @@ import type {
 
 import { GraphQLRequestError, OrmClient, QueryResult } from './client';
 
-export interface QueryBuilderConfig {
+export interface QueryBuilderConfig<TResult> {
   client: OrmClient;
   operation: 'query' | 'mutation';
   operationName: string;
   fieldName: string;
   document: string;
   variables?: Record<string, unknown>;
+  transform?: (data: any) => TResult;
 }
 
 export class QueryBuilder<TResult> {
-  private config: QueryBuilderConfig;
+  private config: QueryBuilderConfig<TResult>;
 
-  constructor(config: QueryBuilderConfig) {
+  constructor(config: QueryBuilderConfig<TResult>) {
     this.config = config;
   }
 
@@ -40,10 +41,21 @@ export class QueryBuilder<TResult> {
    * Use result.ok to check success, or .unwrap() to throw on error
    */
   async execute(): Promise<QueryResult<TResult>> {
-    return this.config.client.execute<TResult>(
+    const rawResult = await this.config.client.execute<any>(
       this.config.document,
       this.config.variables,
     );
+    if (!rawResult.ok) {
+      return rawResult;
+    }
+    if (!this.config.transform) {
+      return rawResult as unknown as QueryResult<TResult>;
+    }
+    return {
+      ok: true,
+      data: this.config.transform(rawResult.data),
+      errors: undefined,
+    };
   }
 
   /**
@@ -91,6 +103,10 @@ export class QueryBuilder<TResult> {
   }
 }
 
+const OP_QUERY = 'query' as unknown as import('graphql').OperationTypeNode;
+const OP_MUTATION = 'mutation' as unknown as import('graphql').OperationTypeNode;
+const ENUM_VALUE_KIND = 'EnumValue' as unknown as EnumValueNode['kind'];
+
 // ============================================================================
 // Selection Builders
 // ============================================================================
@@ -128,48 +144,52 @@ export function buildSelections(
         connection?: boolean;
       };
 
-      if (nested.select) {
-        const relatedEntityType = entityConnections?.[key];
-        const nestedSelections = buildSelections(
-          nested.select,
-          connectionFieldsMap,
-          relatedEntityType,
+      if (!nested.select || typeof nested.select !== 'object') {
+        throw new Error(
+          `Invalid selection for field "${key}": nested selections must include a "select" object.`,
         );
-        const isConnection =
-          nested.connection === true ||
-          nested.first !== undefined ||
-          nested.filter !== undefined ||
-          relatedEntityType !== undefined;
-        const args = buildArgs([
-          buildOptionalArg('first', nested.first),
-          nested.filter
-            ? t.argument({
-                name: 'filter',
-                value: buildValueAst(nested.filter),
-              })
-            : null,
-          buildEnumListArg('orderBy', nested.orderBy),
-        ]);
-
-        if (isConnection) {
-          fields.push(
-            t.field({
-              name: key,
-              args,
-              selectionSet: t.selectionSet({
-                selections: buildConnectionSelections(nestedSelections),
-              }),
-            }),
-          );
-        } else {
-          fields.push(
-            t.field({
-              name: key,
-              args,
-              selectionSet: t.selectionSet({ selections: nestedSelections }),
+      }
+
+      const relatedEntityType = entityConnections?.[key];
+      const nestedSelections = buildSelections(
+        nested.select,
+        connectionFieldsMap,
+        relatedEntityType,
+      );
+      const isConnection =
+        nested.connection === true ||
+        nested.first !== undefined ||
+        nested.filter !== undefined ||
+        relatedEntityType !== undefined;
+      const args = buildArgs([
+        buildOptionalArg('first', nested.first),
+        nested.filter
+          ? t.argument({
+              name: 'filter',
+              value: buildValueAst(nested.filter),
+            })
+          : null,
+        buildEnumListArg('orderBy', nested.orderBy),
+      ]);
+
+      if (isConnection) {
+        fields.push(
+          t.field({
+            name: key,
+            args,
+            selectionSet: t.selectionSet({
+              selections: buildConnectionSelections(nestedSelections),
             }),
-          );
-        }
+          }),
+        );
+      } else {
+        fields.push(
+          t.field({
+            name: key,
+            args,
+            selectionSet: t.selectionSet({ selections: nestedSelections }),
+          }),
+        );
       }
     }
   }
@@ -265,7 +285,7 @@ export function buildFindManyDocument<TSelect, TWhere>(
   const document = t.document({
     definitions: [
       t.operationDefinition({
-        operation: 'query',
+        operation: OP_QUERY,
         name: operationName + 'Query',
         variableDefinitions: variableDefinitions.length
           ? variableDefinitions
@@ -330,7 +350,7 @@ export function buildFindFirstDocument<TSelect, TWhere>(
   const document = t.document({
     definitions: [
       t.operationDefinition({
-        operation: 'query',
+        operation: OP_QUERY,
         name: operationName + 'Query',
         variableDefinitions,
         selectionSet: t.selectionSet({
@@ -405,6 +425,7 @@ export function buildUpdateDocument<
   where: TWhere,
   data: TData,
   inputTypeName: string,
+  patchFieldName: string,
   connectionFieldsMap?: Record<string, Record<string, string>>,
 ): { document: string; variables: Record<string, unknown> } {
   const selections = select
@@ -430,7 +451,7 @@ export function buildUpdateDocument<
     variables: {
       input: {
         id: where.id,
-        patch: data,
+        [patchFieldName]: data,
       },
     },
   };
@@ -445,6 +466,7 @@ export function buildUpdateByPkDocument<TSelect, TData>(
   data: TData,
   inputTypeName: string,
   idFieldName: string,
+  patchFieldName: string,
   connectionFieldsMap?: Record<string, Record<string, string>>,
 ): { document: string; variables: Record<string, unknown> } {
   const selections = select
@@ -470,7 +492,7 @@ export function buildUpdateByPkDocument<TSelect, TData>(
     variables: {
       input: {
         [idFieldName]: id,
-        patch: data,
+        [patchFieldName]: data,
       },
     },
   };
@@ -510,7 +532,7 @@ export function buildFindOneDocument<TSelect>(
   const document = t.document({
     definitions: [
       t.operationDefinition({
-        operation: 'query',
+        operation: OP_QUERY,
         name: operationName + 'Query',
         variableDefinitions,
         selectionSet: t.selectionSet({
@@ -622,15 +644,12 @@ export function buildCustomDocument<TSelect, TArgs>(
   connectionFieldsMap?: Record<string, Record<string, string>>,
   entityType?: string,
 ): { document: string; variables: Record<string, unknown> } {
-  let actualSelect = select;
+  let actualSelect: TSelect = select;
   let isConnection = false;
 
-  if (select && typeof select === 'object' && 'select' in select) {
-    const wrapper = select as { select?: TSelect; connection?: boolean };
-    if (wrapper.select) {
-      actualSelect = wrapper.select;
-      isConnection = wrapper.connection === true;
-    }
+  if (isCustomSelectionWrapper(select)) {
+    actualSelect = select.select as TSelect;
+    isConnection = select.connection === true;
   }
 
   const selections = actualSelect
@@ -661,7 +680,7 @@ export function buildCustomDocument<TSelect, TArgs>(
   const document = t.document({
     definitions: [
       t.operationDefinition({
-        operation: operationType,
+        operation: operationType === 'mutation' ? OP_MUTATION : OP_QUERY,
         name: operationName,
         variableDefinitions: variableDefs.length ? variableDefs : undefined,
         selectionSet: t.selectionSet({
@@ -685,6 +704,31 @@ export function buildCustomDocument<TSelect, TArgs>(
   };
 }
 
+function isCustomSelectionWrapper(
+  value: unknown,
+): value is { select: Record<string, unknown>; connection?: boolean } {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+
+  const record = value as Record<string, unknown>;
+  const keys = Object.keys(record);
+
+  if (!keys.includes('select') || !keys.includes('connection')) {
+    return false;
+  }
+
+  if (keys.some((key) => key !== 'select' && key !== 'connection')) {
+    return false;
+  }
+
+  return (
+    !!record.select &&
+    typeof record.select === 'object' &&
+    !Array.isArray(record.select)
+  );
+}
+
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -724,7 +768,7 @@ function buildEnumListArg(
 
 function buildEnumValue(value: string): EnumValueNode {
   return {
-    kind: 'EnumValue',
+    kind: ENUM_VALUE_KIND,
     value,
   };
 }
@@ -770,7 +814,7 @@ function buildInputMutationDocument(config: InputMutationConfig): string {
   const document = t.document({
     definitions: [
       t.operationDefinition({
-        operation: 'mutation',
+        operation: OP_MUTATION,
         name: config.operationName + 'Mutation',
         variableDefinitions: [
           t.variableDefinition({

package/core/codegen/templates/select-types.ts

@@ -61,44 +61,60 @@ export interface DeleteArgs<TWhere, TSelect = undefined> {
   select?: TSelect;
 }
 
+type DepthLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type DecrementDepth = {
+  0: 0;
+  1: 0;
+  2: 1;
+  3: 2;
+  4: 3;
+  5: 4;
+  6: 5;
+  7: 6;
+  8: 7;
+  9: 8;
+  10: 9;
+};
+
 /**
  * Recursively validates select objects, rejecting unknown keys.
  *
- * NOTE: This type is intentionally NOT used in generated parameter positions
- * (conditional types block IDE autocompletion). Parameters use `S` directly
- * with `S extends XxxSelect` constraints, which provides full
- * autocompletion via TypeScript's contextual typing.
- *
- * @example
- * // This will cause a type error because 'invalid' doesn't exist:
- * type Result = DeepExact<{ id: true, invalid: true }, { id?: boolean }>;
- * // Result = never (causes assignment error)
- *
- * @example
- * // This works because all fields are valid:
- * type Result = DeepExact<{ id: true }, { id?: boolean; name?: boolean }>;
- * // Result = { id: true }
+ * NOTE: Depth is intentionally capped to avoid circular-instantiation issues
+ * in very large cyclic schemas.
  */
-export type DeepExact<T, Shape> = T extends Shape
-  ? Exclude<keyof T, keyof Shape> extends never
-    ? {
-        [K in keyof T]: K extends keyof Shape
-          ? T[K] extends { select: infer NS }
-            ? Extract<Shape[K], { select?: unknown }> extends {
-                select?: infer ShapeNS;
-              }
-              ? DeepExact<
-                  Omit<T[K], 'select'> & {
-                    select: DeepExact<NS, NonNullable<ShapeNS>>;
-                  },
-                  Extract<Shape[K], { select?: unknown }>
-                >
-              : never
-            : T[K]
-          : never;
-      }
+export type DeepExact<
+  T,
+  Shape,
+  Depth extends DepthLevel = 10,
+> = Depth extends 0
+  ? T extends Shape
+    ? T
     : never
-  : never;
+  : T extends Shape
+    ? Exclude<keyof T, keyof Shape> extends never
+      ? {
+          [K in keyof T]: K extends keyof Shape
+            ? T[K] extends { select: infer NS }
+              ? Extract<Shape[K], { select?: unknown }> extends {
+                  select?: infer ShapeNS;
+                }
+                ? DeepExact<
+                    Omit<T[K], 'select'> & {
+                      select: DeepExact<
+                        NS,
+                        NonNullable<ShapeNS>,
+                        DecrementDepth[Depth]
+                      >;
+                    },
+                    Extract<Shape[K], { select?: unknown }>,
+                    DecrementDepth[Depth]
+                  >
+                : never
+              : T[K]
+            : never;
+        }
+      : never
+    : never;
 
 /**
  * Enforces exact select shape while keeping contextual typing on `S extends XxxSelect`.
@@ -107,6 +123,16 @@ export type DeepExact<T, Shape> = T extends Shape
  */
 export type StrictSelect<S, Shape> = S extends DeepExact<S, Shape> ? {} : never;
 
+/**
+ * Hook-optimized strict select variant.
+ *
+ * Uses a shallower recursion depth to keep editor autocomplete responsive
+ * in large schemas while still validating common nested-select mistakes.
+ */
+export type HookStrictSelect<S, Shape> = S extends DeepExact<S, Shape, 5>
+  ? {}
+  : never;
+
 /**
  * Infer result type from select configuration
  */