@constructive-io/graphql-codegen 3.3.2 → 4.0.0

package/esm/core/codegen/orm/model-generator.js

@@ -6,14 +6,14 @@
  */
 import * as t from '@babel/types';
 import { generateCode } from '../babel-ast';
-import { getFilterTypeName, getGeneratedFileHeader, getOrderByTypeName, getPrimaryKeyInfo, getTableNames, hasValidPrimaryKey, lcFirst, } from '../utils';
+import { getFilterTypeName, getGeneratedFileHeader, getOrderByTypeName, getPrimaryKeyInfo, getSingleRowQueryName, getTableNames, hasValidPrimaryKey, lcFirst, } from '../utils';
 function createImportDeclaration(moduleSpecifier, namedImports, typeOnly = false) {
     const specifiers = namedImports.map((name) => t.importSpecifier(t.identifier(name), t.identifier(name)));
     const decl = t.importDeclaration(specifiers, t.stringLiteral(moduleSpecifier));
     decl.importKind = typeOnly ? 'type' : 'value';
     return decl;
 }
-function buildMethodBody(builderFn, args, operation, typeName, fieldName) {
+function buildMethodBody(builderFn, args, operation, typeName, fieldName, extraProps = []) {
     const destructureDecl = t.variableDeclaration('const', [
         t.variableDeclarator(t.objectPattern([
             t.objectProperty(t.identifier('document'), t.identifier('document'), false, true),
@@ -28,6 +28,7 @@ function buildMethodBody(builderFn, args, operation, typeName, fieldName) {
             t.objectProperty(t.identifier('fieldName'), t.stringLiteral(fieldName)),
             t.objectProperty(t.identifier('document'), t.identifier('document'), false, true),
             t.objectProperty(t.identifier('variables'), t.identifier('variables'), false, true),
+            ...extraProps,
         ]),
     ]));
     return [destructureDecl, returnStmt];
@@ -38,10 +39,6 @@ function createClassMethod(name, typeParameters, params, returnType, body) {
     method.returnType = returnType;
     return method;
 }
-function createDeclareMethod(name, typeParameters, params, returnType) {
-    const method = t.tsDeclareMethod(null, t.identifier(name), typeParameters, params, returnType);
-    return method;
-}
 function createTypeParam(constraintTypeName, defaultType) {
     const param = t.tsTypeParameter(t.tsTypeReference(t.identifier(constraintTypeName)), defaultType ?? null, 'S');
     return t.tsTypeParameterDeclaration([param]);
@@ -85,6 +82,8 @@ export function generateModelFile(table, _useSharedTypes) {
     const pkFields = getPrimaryKeyInfo(table);
     const pkField = pkFields[0];
     const pluralQueryName = table.query?.all ?? pluralName;
+    const singleQueryName = table.query?.one;
+    const singleResultFieldName = getSingleRowQueryName(table);
     const createMutationName = table.query?.create ?? `create${typeName}`;
     const updateMutationName = table.query?.update;
     const deleteMutationName = table.query?.delete;
@@ -129,7 +128,6 @@ export function generateModelFile(table, _useSharedTypes) {
     classBody.push(t.classMethod('constructor', t.identifier('constructor'), [paramProp], t.blockStatement([])));
     // Reusable type reference factories
     const sRef = () => t.tsTypeReference(t.identifier('S'));
-    const selectRef = () => t.tsTypeReference(t.identifier(selectTypeName));
     const pkTsType = () => tsTypeFromPrimitive(pkField.tsType);
     // ── findMany ───────────────────────────────────────────────────────────
     {
@@ -148,17 +146,12 @@ export function generateModelFile(table, _useSharedTypes) {
                 ])))),
             ]),
         ])));
-        // Overload 1: with select (autocompletion)
-        const o1Param = t.identifier('args');
-        o1Param.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
+        const implParam = t.identifier('args');
+        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
             argsType(sRef()),
             t.tsTypeLiteral([requiredSelectProp()]),
             strictSelectGuard(selectTypeName),
         ]));
-        classBody.push(createDeclareMethod('findMany', createTypeParam(selectTypeName), [o1Param], retType(sRef())));
-        // Implementation
-        const implParam = t.identifier('args');
-        implParam.typeAnnotation = t.tsTypeAnnotation(argsType(selectRef()));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
         const bodyArgs = [
             t.stringLiteral(typeName),
@@ -180,7 +173,7 @@ export function generateModelFile(table, _useSharedTypes) {
             t.stringLiteral(orderByTypeName),
             t.identifier('connectionFieldsMap'),
         ];
-        classBody.push(createClassMethod('findMany', null, [implParam], null, buildMethodBody('buildFindManyDocument', bodyArgs, 'query', typeName, pluralQueryName)));
+        classBody.push(createClassMethod('findMany', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindManyDocument', bodyArgs, 'query', typeName, pluralQueryName)));
     }
     // ── findFirst ──────────────────────────────────────────────────────────
     {
@@ -198,17 +191,12 @@ export function generateModelFile(table, _useSharedTypes) {
                 ]))),
             ]),
         ])));
-        // Overload 1: with select (autocompletion)
-        const o1Param = t.identifier('args');
-        o1Param.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
+        const implParam = t.identifier('args');
+        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
             argsType(sRef()),
             t.tsTypeLiteral([requiredSelectProp()]),
             strictSelectGuard(selectTypeName),
         ]));
-        classBody.push(createDeclareMethod('findFirst', createTypeParam(selectTypeName), [o1Param], retType(sRef())));
-        // Implementation
-        const implParam = t.identifier('args');
-        implParam.typeAnnotation = t.tsTypeAnnotation(argsType(selectRef()));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
         const bodyArgs = [
             t.stringLiteral(typeName),
@@ -220,15 +208,13 @@ export function generateModelFile(table, _useSharedTypes) {
             t.stringLiteral(whereTypeName),
             t.identifier('connectionFieldsMap'),
         ];
-        classBody.push(createClassMethod('findFirst', null, [implParam], null, buildMethodBody('buildFindFirstDocument', bodyArgs, 'query', typeName, pluralQueryName)));
+        classBody.push(createClassMethod('findFirst', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindFirstDocument', bodyArgs, 'query', typeName, pluralQueryName)));
     }
     // ── findOne ────────────────────────────────────────────────────────────
-    const singleQueryName = table.query?.one;
-    if (singleQueryName && hasValidPrimaryKey(table)) {
-        const pkGqlType = pkField.gqlType.replace(/!/g, '') + '!';
+    if (hasValidPrimaryKey(table)) {
         const retType = (sel) => t.tsTypeAnnotation(t.tsTypeReference(t.identifier('QueryBuilder'), t.tsTypeParameterInstantiation([
             t.tsTypeLiteral([
-                t.tsPropertySignature(t.identifier(singleQueryName), t.tsTypeAnnotation(t.tsUnionType([
+                t.tsPropertySignature(t.identifier(singleResultFieldName), t.tsTypeAnnotation(t.tsUnionType([
                     t.tsTypeReference(t.identifier('InferSelectResult'), t.tsTypeParameterInstantiation([
                         t.tsTypeReference(t.identifier(relationTypeName)),
                         sel,
@@ -242,33 +228,59 @@ export function generateModelFile(table, _useSharedTypes) {
             prop.optional = false;
             return prop;
         };
-        // Overload 1: with select (autocompletion)
-        const o1Param = t.identifier('args');
-        o1Param.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
+        const implParam = t.identifier('args');
+        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
             t.tsTypeLiteral([pkProp(), requiredSelectProp()]),
             strictSelectGuard(selectTypeName),
         ]));
-        classBody.push(createDeclareMethod('findOne', createTypeParam(selectTypeName), [o1Param], retType(sRef())));
-        // Implementation
-        const implParam = t.identifier('args');
-        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([
-            pkProp(),
-            (() => {
-                const prop = t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(selectTypeName))));
-                return prop;
-            })(),
-        ]));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
-        const bodyArgs = [
-            t.stringLiteral(typeName),
-            t.stringLiteral(singleQueryName),
-            t.memberExpression(t.identifier('args'), t.identifier(pkField.name)),
-            selectExpr,
-            t.stringLiteral(pkField.name),
-            t.stringLiteral(pkGqlType),
-            t.identifier('connectionFieldsMap'),
-        ];
-        classBody.push(createClassMethod('findOne', null, [implParam], null, buildMethodBody('buildFindOneDocument', bodyArgs, 'query', typeName, singleQueryName)));
+        if (singleQueryName) {
+            const pkGqlType = pkField.gqlType.replace(/!/g, '') + '!';
+            const bodyArgs = [
+                t.stringLiteral(typeName),
+                t.stringLiteral(singleQueryName),
+                t.memberExpression(t.identifier('args'), t.identifier(pkField.name)),
+                selectExpr,
+                t.stringLiteral(pkField.name),
+                t.stringLiteral(pkGqlType),
+                t.identifier('connectionFieldsMap'),
+            ];
+            classBody.push(createClassMethod('findOne', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindOneDocument', bodyArgs, 'query', typeName, singleResultFieldName)));
+        }
+        else {
+            const idExpr = t.memberExpression(t.identifier('args'), t.identifier(pkField.name));
+            const findOneArgs = t.objectExpression([
+                t.objectProperty(t.identifier('where'), t.objectExpression([
+                    t.objectProperty(t.identifier(pkField.name), t.objectExpression([
+                        t.objectProperty(t.identifier('equalTo'), idExpr),
+                    ])),
+                ])),
+                t.objectProperty(t.identifier('first'), t.numericLiteral(1)),
+            ]);
+            const bodyArgs = [
+                t.stringLiteral(typeName),
+                t.stringLiteral(pluralQueryName),
+                selectExpr,
+                findOneArgs,
+                t.stringLiteral(whereTypeName),
+                t.stringLiteral(orderByTypeName),
+                t.identifier('connectionFieldsMap'),
+            ];
+            const firstNodeExpr = t.optionalMemberExpression(t.optionalMemberExpression(t.memberExpression(t.identifier('data'), t.identifier(pluralQueryName)), t.identifier('nodes'), false, true), t.numericLiteral(0), true, true);
+            const transformDataParam = t.identifier('data');
+            const transformedNodesProp = t.tsPropertySignature(t.identifier('nodes'), t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('InferSelectResult'), t.tsTypeParameterInstantiation([
+                t.tsTypeReference(t.identifier(relationTypeName)),
+                sRef(),
+            ])))));
+            transformedNodesProp.optional = true;
+            const transformedCollectionProp = t.tsPropertySignature(t.identifier(pluralQueryName), t.tsTypeAnnotation(t.tsTypeLiteral([transformedNodesProp])));
+            transformedCollectionProp.optional = true;
+            transformDataParam.typeAnnotation = t.tsTypeAnnotation(t.tsTypeLiteral([transformedCollectionProp]));
+            const transformFn = t.arrowFunctionExpression([transformDataParam], t.objectExpression([
+                t.objectProperty(t.stringLiteral(singleResultFieldName), t.logicalExpression('??', firstNodeExpr, t.nullLiteral())),
+            ]));
+            classBody.push(createClassMethod('findOne', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildFindManyDocument', bodyArgs, 'query', typeName, singleResultFieldName, [t.objectProperty(t.identifier('transform'), transformFn)])));
+        }
     }
     // ── create ─────────────────────────────────────────────────────────────
     {
@@ -284,17 +296,12 @@ export function generateModelFile(table, _useSharedTypes) {
                 ]))),
             ]),
         ])));
-        // Overload 1: with select (autocompletion)
-        const o1Param = t.identifier('args');
-        o1Param.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
+        const implParam = t.identifier('args');
+        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
             argsType(sRef()),
             t.tsTypeLiteral([requiredSelectProp()]),
             strictSelectGuard(selectTypeName),
         ]));
-        classBody.push(createDeclareMethod('create', createTypeParam(selectTypeName), [o1Param], retType(sRef())));
-        // Implementation
-        const implParam = t.identifier('args');
-        implParam.typeAnnotation = t.tsTypeAnnotation(argsType(selectRef()));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
         const bodyArgs = [
             t.stringLiteral(typeName),
@@ -305,7 +312,7 @@ export function generateModelFile(table, _useSharedTypes) {
             t.stringLiteral(createInputTypeName),
             t.identifier('connectionFieldsMap'),
         ];
-        classBody.push(createClassMethod('create', null, [implParam], null, buildMethodBody('buildCreateDocument', bodyArgs, 'mutation', typeName, createMutationName)));
+        classBody.push(createClassMethod('create', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildCreateDocument', bodyArgs, 'mutation', typeName, createMutationName)));
     }
     // ── update ─────────────────────────────────────────────────────────────
     if (updateMutationName) {
@@ -331,18 +338,14 @@ export function generateModelFile(table, _useSharedTypes) {
                 ]))),
             ]),
         ])));
-        // Overload 1: with select (autocompletion)
-        const o1Param = t.identifier('args');
-        o1Param.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
+        const implParam = t.identifier('args');
+        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
             argsType(sRef()),
             t.tsTypeLiteral([requiredSelectProp()]),
             strictSelectGuard(selectTypeName),
         ]));
-        classBody.push(createDeclareMethod('update', createTypeParam(selectTypeName), [o1Param], retType(sRef())));
-        // Implementation
-        const implParam = t.identifier('args');
-        implParam.typeAnnotation = t.tsTypeAnnotation(argsType(selectRef()));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
+        const patchFieldName = table.query?.patchFieldName ?? lcFirst(typeName) + 'Patch';
         const bodyArgs = [
             t.stringLiteral(typeName),
             t.stringLiteral(updateMutationName),
@@ -352,9 +355,10 @@ export function generateModelFile(table, _useSharedTypes) {
             t.memberExpression(t.identifier('args'), t.identifier('data')),
             t.stringLiteral(updateInputTypeName),
             t.stringLiteral(pkField.name),
+            t.stringLiteral(patchFieldName),
             t.identifier('connectionFieldsMap'),
         ];
-        classBody.push(createClassMethod('update', null, [implParam], null, buildMethodBody('buildUpdateByPkDocument', bodyArgs, 'mutation', typeName, updateMutationName)));
+        classBody.push(createClassMethod('update', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildUpdateByPkDocument', bodyArgs, 'mutation', typeName, updateMutationName)));
     }
     // ── delete ─────────────────────────────────────────────────────────────
     if (deleteMutationName) {
@@ -376,17 +380,12 @@ export function generateModelFile(table, _useSharedTypes) {
                 ]))),
             ]),
         ])));
-        // Overload 1: with select (autocompletion)
-        const o1Param = t.identifier('args');
-        o1Param.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
+        const implParam = t.identifier('args');
+        implParam.typeAnnotation = t.tsTypeAnnotation(t.tsIntersectionType([
             argsType(sRef()),
             t.tsTypeLiteral([requiredSelectProp()]),
             strictSelectGuard(selectTypeName),
         ]));
-        classBody.push(createDeclareMethod('delete', createTypeParam(selectTypeName), [o1Param], retType(sRef())));
-        // Implementation
-        const implParam = t.identifier('args');
-        implParam.typeAnnotation = t.tsTypeAnnotation(argsType(selectRef()));
         const selectExpr = t.memberExpression(t.identifier('args'), t.identifier('select'));
         const bodyArgs = [
             t.stringLiteral(typeName),
@@ -398,7 +397,7 @@ export function generateModelFile(table, _useSharedTypes) {
             selectExpr,
             t.identifier('connectionFieldsMap'),
         ];
-        classBody.push(createClassMethod('delete', null, [implParam], null, buildMethodBody('buildDeleteByPkDocument', bodyArgs, 'mutation', typeName, deleteMutationName)));
+        classBody.push(createClassMethod('delete', createTypeParam(selectTypeName), [implParam], retType(sRef()), buildMethodBody('buildDeleteByPkDocument', bodyArgs, 'mutation', typeName, deleteMutationName)));
     }
     const classDecl = t.classDeclaration(t.identifier(modelName), null, t.classBody(classBody));
     statements.push(t.exportNamedDeclaration(classDecl));

package/esm/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/esm/core/codegen/queries.js

@@ -38,7 +38,12 @@ export function generateListQueryHook(table, options = {}) {
         }
     }
     statements.push(createImportDeclaration('../../orm/input-types', [selectTypeName, relationTypeName, filterTypeName, orderByTypeName], true));
-    statements.push(createImportDeclaration('../../orm/select-types', ['FindManyArgs', 'InferSelectResult', 'ConnectionResult', 'StrictSelect'], true));
+    statements.push(createImportDeclaration('../../orm/select-types', [
+        'FindManyArgs',
+        'InferSelectResult',
+        'ConnectionResult',
+        'HookStrictSelect',
+    ], true));
     // Re-exports
     statements.push(createTypeReExport([selectTypeName, relationTypeName, filterTypeName, orderByTypeName], '../../orm/input-types'));
     // Query key
@@ -155,8 +160,10 @@ export function generateListQueryHook(table, options = {}) {
     const fetchFnName = `fetch${ucFirst(pluralName)}Query`;
     {
         // Overload 1: with fields
-        const f1ParamType = t.tsTypeLiteral([
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsListSelectionType(sRef(), selectTypeName, filterTypeName, orderByTypeName))),
+        const f1ParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsListSelectionType(sRef(), selectTypeName, filterTypeName, orderByTypeName))),
+            ]),
         ]);
         const f1Decl = exportAsyncDeclareFunction(fetchFnName, createSTypeParam(selectTypeName), [createFunctionParam('params', f1ParamType)], typeRef('Promise', [listResultTypeAST(sRef())]));
         addJSDocComment(f1Decl, [
@@ -186,15 +193,17 @@ export function generateListQueryHook(table, options = {}) {
     if (reactQueryEnabled) {
         const prefetchFnName = `prefetch${ucFirst(pluralName)}Query`;
         // Overload 1: with fields
-        const p1Params = [
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsListSelectionType(sRef(), selectTypeName, filterTypeName, orderByTypeName))),
-        ];
+        const p1BaseParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsListSelectionType(sRef(), selectTypeName, filterTypeName, orderByTypeName))),
+            ]),
+        ]);
         const p1ParamType = hasRelationships && useCentralizedKeys
             ? t.tsIntersectionType([
-                t.tsTypeLiteral(p1Params),
+                p1BaseParamType,
                 scopeTypeLiteral(scopeTypeName),
             ])
-            : t.tsTypeLiteral(p1Params);
+            : p1BaseParamType;
         const p1Decl = exportAsyncDeclareFunction(prefetchFnName, createSTypeParam(selectTypeName), [
             createFunctionParam('queryClient', typeRef('QueryClient')),
             createFunctionParam('params', p1ParamType),
@@ -277,7 +286,7 @@ export function generateSingleQueryHook(table, options = {}) {
         }
     }
     statements.push(createImportDeclaration('../../orm/input-types', [selectTypeName, relationTypeName], true));
-    statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'StrictSelect'], true));
+    statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'HookStrictSelect'], true));
     // Re-exports
     statements.push(createTypeReExport([selectTypeName, relationTypeName], '../../orm/input-types'));
     // Query key
@@ -345,12 +354,11 @@ export 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(withFieldsSelectionType(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(withFieldsSelectionType(sRef(), selectTypeName))),
+            ]),
             buildSingleOptionsType(singleResultTypeAST(sRef()), typeRef('TData')),
         ]);
         const o1 = exportDeclareFunction(hookName, createSAndTDataTypeParams(selectTypeName, singleResultTypeAST(sRef())), [createFunctionParam('params', o1ParamType)], typeRef('UseQueryResult', [typeRef('TData')]));
@@ -393,11 +401,13 @@ export function generateSingleQueryHook(table, options = {}) {
     const fetchFnName = `fetch${ucFirst(singularName)}Query`;
     {
         // Overload 1: with fields
-        const f1Props = [
-            t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsSelectionType(sRef(), selectTypeName))),
-        ];
-        const f1Decl = exportAsyncDeclareFunction(fetchFnName, createSTypeParam(selectTypeName), [createFunctionParam('params', t.tsTypeLiteral(f1Props))], typeRef('Promise', [singleResultTypeAST(sRef())]));
+        const f1ParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsSelectionType(sRef(), selectTypeName))),
+            ]),
+        ]);
+        const f1Decl = exportAsyncDeclareFunction(fetchFnName, createSTypeParam(selectTypeName), [createFunctionParam('params', f1ParamType)], typeRef('Promise', [singleResultTypeAST(sRef())]));
         addJSDocComment(f1Decl, [
             `Fetch a single ${typeName} without React hooks`,
             '',
@@ -424,16 +434,18 @@ export function generateSingleQueryHook(table, options = {}) {
     if (reactQueryEnabled) {
         const prefetchFnName = `prefetch${ucFirst(singularName)}Query`;
         // Overload 1: with fields
-        const p1Props = [
-            t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
-            t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsSelectionType(sRef(), selectTypeName))),
-        ];
+        const p1BaseParamType = t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier(pkFieldName), t.tsTypeAnnotation(pkTsType)),
+                t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(withFieldsSelectionType(sRef(), selectTypeName))),
+            ]),
+        ]);
         const p1ParamType = hasRelationships && useCentralizedKeys
             ? t.tsIntersectionType([
-                t.tsTypeLiteral(p1Props),
+                p1BaseParamType,
                 scopeTypeLiteral(scopeTypeName),
             ])
-            : t.tsTypeLiteral(p1Props);
+            : p1BaseParamType;
         const p1Decl = exportAsyncDeclareFunction(prefetchFnName, createSTypeParam(selectTypeName), [
             createFunctionParam('queryClient', typeRef('QueryClient')),
             createFunctionParam('params', p1ParamType),

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

@@ -60,6 +60,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 (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();
@@ -224,6 +243,7 @@ export 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);
@@ -239,6 +259,7 @@ export 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/esm/core/codegen/types.js

@@ -2,6 +2,7 @@
  * Types generator - generates types.ts with entity interfaces using Babel AST
  */
 import * as t from '@babel/types';
+import { SCALAR_NAMES } from './scalars';
 import { generateCode } from './babel-ast';
 import { fieldTypeToTs, getGeneratedFileHeader, getScalarFields, } from './utils';
 /** All filter type configurations - scalar and list filters */
@@ -151,12 +152,34 @@ function createInterfaceDeclaration(name, properties) {
     const interfaceDecl = t.tsInterfaceDeclaration(t.identifier(name), null, null, t.tsInterfaceBody(props));
     return t.exportNamedDeclaration(interfaceDecl);
 }
+function createTypeAlias(name, typeNode) {
+    const typeAlias = t.tsTypeAliasDeclaration(t.identifier(name), null, typeNode);
+    return t.exportNamedDeclaration(typeAlias);
+}
+function collectCustomScalarTypes(tables, excludedTypeNames) {
+    const customScalarTypes = new Set();
+    const tableTypeNames = new Set(tables.map((table) => table.name));
+    for (const table of tables) {
+        for (const field of getScalarFields(table)) {
+            const cleanType = field.type.gqlType.replace(/!/g, '');
+            if (SCALAR_NAMES.has(cleanType))
+                continue;
+            if (excludedTypeNames.has(cleanType))
+                continue;
+            if (tableTypeNames.has(cleanType))
+                continue;
+            customScalarTypes.add(cleanType);
+        }
+    }
+    return Array.from(customScalarTypes).sort();
+}
 /**
  * Generate types.ts content with all entity interfaces and base filter types
  */
 export function generateTypesFile(tables, options = {}) {
     const { enumsFromSchemaTypes = [] } = options;
     const enumSet = new Set(enumsFromSchemaTypes);
+    const customScalarTypes = collectCustomScalarTypes(tables, enumSet);
     const statements = [];
     // Collect which enums are actually used by entity fields
     const usedEnums = new Set();
@@ -179,6 +202,9 @@ export function generateTypesFile(tables, options = {}) {
         importDecl.importKind = 'type';
         statements.push(importDecl);
     }
+    for (const scalarType of customScalarTypes) {
+        statements.push(createTypeAlias(scalarType, t.tsUnknownKeyword()));
+    }
     // Generate entity interfaces
     for (const table of tables) {
         const scalarFields = getScalarFields(table);

package/esm/core/codegen/utils.d.ts

@@ -72,7 +72,7 @@ export declare function getUpdateMutationFileName(table: CleanTable): string;
 export declare function getDeleteMutationFileName(table: CleanTable): string;
 /**
  * Get the GraphQL query name for fetching all rows
- * Uses inflection from _meta, falls back to convention
+ * Uses inflection from introspection, falls back to convention
  */
 export declare function getAllRowsQueryName(table: CleanTable): string;
 /**

package/esm/core/codegen/utils.js

@@ -128,7 +128,7 @@ export function getDeleteMutationFileName(table) {
 // ============================================================================
 /**
  * Get the GraphQL query name for fetching all rows
- * Uses inflection from _meta, falls back to convention
+ * Uses inflection from introspection, falls back to convention
  */
 export function getAllRowsQueryName(table) {
     return (table.query?.all ||

package/esm/core/custom-ast.js

@@ -1,4 +1,5 @@
 import * as t from 'gql-ast';
+import { Kind } from 'graphql';
 /**
  * Get custom AST for MetaField type - handles PostgreSQL types that need subfield selections
  */
@@ -76,28 +77,28 @@ export function geometryPointAst(name) {
 export function geometryCollectionAst(name) {
     // Manually create inline fragment since gql-ast doesn't support it
     const inlineFragment = {
-        kind: 'InlineFragment',
+        kind: Kind.INLINE_FRAGMENT,
         typeCondition: {
-            kind: 'NamedType',
+            kind: Kind.NAMED_TYPE,
             name: {
-                kind: 'Name',
+                kind: Kind.NAME,
                 value: 'GeometryPoint',
             },
         },
         selectionSet: {
-            kind: 'SelectionSet',
+            kind: Kind.SELECTION_SET,
             selections: [
                 {
-                    kind: 'Field',
+                    kind: Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: Kind.NAME,
                         value: 'x',
                     },
                 },
                 {
-                    kind: 'Field',
+                    kind: Kind.FIELD,
                     name: {
-                        kind: 'Name',
+                        kind: Kind.NAME,
                         value: 'y',
                     },
                 },