@constructive-io/graphql-codegen 3.2.0 → 3.3.0

package/core/codegen/hooks-ast.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Shared Babel AST helpers for React Query hook generators
+ *
+ * Provides reusable AST-building functions for the common patterns
+ * used across queries.ts, mutations.ts, custom-queries.ts, and custom-mutations.ts.
+ */
+import * as t from '@babel/types';
+import type { CleanArgument } from '../../types/schema';
+export declare function createImportDeclaration(moduleSpecifier: string, namedImports: string[], typeOnly?: boolean): t.ImportDeclaration;
+export declare function createTypeReExport(names: string[], moduleSpecifier: string): t.ExportNamedDeclaration;
+export declare function typeRef(name: string, params?: t.TSType[]): t.TSTypeReference;
+export declare function sRef(): t.TSTypeReference;
+export declare function typeofRef(name: string): t.TSTypeQuery;
+export declare function stringLiteralType(value: string): t.TSLiteralType;
+export declare function inferSelectResultType(entityTypeName: string, selectType: t.TSType): t.TSTypeReference;
+export declare function connectionResultType(entityTypeName: string, selectType: t.TSType): t.TSTypeReference;
+export declare function typeLiteralWithProps(props: Array<{
+    name: string;
+    type: t.TSType;
+    optional?: boolean;
+}>): t.TSTypeLiteral;
+export declare function queryResultType(queryName: string, innerType: t.TSType): t.TSTypeLiteral;
+export declare function listQueryResultType(queryName: string, entityTypeName: string, selectType: t.TSType): t.TSTypeLiteral;
+export declare function singleQueryResultType(queryName: string, entityTypeName: string, selectType: t.TSType, nullable?: boolean): t.TSTypeLiteral;
+export declare function mutationResultType(mutationName: string, entityField: string, entityTypeName: string, selectType: t.TSType): t.TSTypeLiteral;
+export declare function omitType(baseType: t.TSType, keys: string[]): t.TSTypeReference;
+export declare function listSelectionConfigType(selectType: t.TSType, filterTypeName: string, orderByTypeName: string): t.TSTypeReference;
+export declare function selectionConfigType(selectType: t.TSType): t.TSTypeReference;
+export declare function strictSelectType(selectType: t.TSType, shapeTypeName: string): t.TSTypeReference;
+export declare function withFieldsSelectionType(selectType: t.TSType, selectTypeName: string): t.TSIntersectionType;
+export declare function withFieldsListSelectionType(selectType: t.TSType, selectTypeName: string, filterTypeName: string, orderByTypeName: string): t.TSIntersectionType;
+export declare function useQueryOptionsType(queryDataType: t.TSType, dataType: t.TSType, extraProps?: t.TSType): t.TSType;
+export declare function useQueryOptionsImplType(extraProps?: t.TSType): t.TSType;
+export declare function useMutationOptionsType(resultType: t.TSType, varType: t.TSType): t.TSTypeReference;
+export declare function useMutationResultType(resultType: t.TSType, varType: t.TSType): t.TSTypeReference;
+export declare function createSTypeParam(constraintName: string): t.TSTypeParameterDeclaration;
+export declare function createSAndTDataTypeParams(constraintName: string, defaultDataType: t.TSType): t.TSTypeParameterDeclaration;
+export declare function createTDataTypeParam(defaultType: t.TSType): t.TSTypeParameterDeclaration;
+export declare function createFunctionParam(name: string, typeAnnotation: t.TSType, optional?: boolean): t.Identifier;
+export declare function exportDeclareFunction(name: string, typeParameters: t.TSTypeParameterDeclaration | null, params: t.Identifier[], returnType: t.TSType): t.ExportNamedDeclaration;
+export declare function exportFunction(name: string, typeParameters: t.TSTypeParameterDeclaration | null, params: t.Identifier[], body: t.Statement[], returnType?: t.TSType): t.ExportNamedDeclaration;
+export declare function exportAsyncFunction(name: string, typeParameters: t.TSTypeParameterDeclaration | null, params: t.Identifier[], body: t.Statement[], returnType?: t.TSType): t.ExportNamedDeclaration;
+export declare function exportAsyncDeclareFunction(name: string, typeParameters: t.TSTypeParameterDeclaration | null, params: t.Identifier[], returnType: t.TSType): t.ExportNamedDeclaration;
+export declare function callExpr(callee: string | t.Expression, args: (t.Expression | t.SpreadElement)[]): t.CallExpression;
+export declare function memberExpr(obj: string, prop: string): t.MemberExpression;
+export declare function optionalMemberExpr(obj: string, prop: string): t.OptionalMemberExpression;
+export declare function arrowFn(params: t.Identifier[], body: t.Expression | t.BlockStatement): t.ArrowFunctionExpression;
+export declare function awaitExpr(expr: t.Expression): t.AwaitExpression;
+export declare function spreadObj(expr: t.Expression): t.SpreadElement;
+export declare function objectProp(key: string, value: t.Expression, shorthand?: boolean): t.ObjectProperty;
+export declare function shorthandProp(name: string): t.ObjectProperty;
+export declare function constDecl(name: string, init: t.Expression): t.VariableDeclaration;
+export declare function asConstExpr(expr: t.Expression): t.TSAsExpression;
+export declare function asTypeExpr(expr: t.Expression, typeName: string): t.TSAsExpression;
+export declare function voidStatement(name: string): t.ExpressionStatement;
+export declare function returnUseQuery(queryKeyExpr: t.Expression, queryFnExpr: t.Expression, extraProps?: Array<t.ObjectProperty | t.SpreadElement>, enabledExpr?: t.Expression): t.ReturnStatement;
+export declare function returnUseMutation(mutationFnExpr: t.Expression, extraProps: Array<t.ObjectProperty | t.SpreadElement>, mutationKeyExpr?: t.Expression): t.ReturnStatement;
+export declare function destructureWithRest(source: t.Expression, keys: string[], restName: string): t.VariableDeclaration;
+export declare function destructureParamsWithSelection(restName: string, extraKeys?: string[]): t.VariableDeclaration;
+export declare function destructureParamsWithSelectionAndScope(restName: string): t.VariableDeclaration;
+export declare function addJSDocComment<T extends t.Node>(node: T, lines: string[]): T;
+export declare function addLineComment<T extends t.Node>(node: T, text: string): T;
+export declare function getClientCall(modelName: string, method: string, args: t.Expression): t.CallExpression;
+export declare function getClientCallUnwrap(modelName: string, method: string, args: t.Expression): t.CallExpression;
+export declare function getClientCustomCall(operationType: 'query' | 'mutation', operationName: string, args: t.Expression[], optionsArg?: t.Expression): t.CallExpression;
+export declare function getClientCustomCallUnwrap(operationType: 'query' | 'mutation', operationName: string, args: t.Expression[], optionsArg?: t.Expression): t.CallExpression;
+export declare function buildFindManyCallExpr(singularName: string, argsIdent: string): t.CallExpression;
+export declare function buildFindOneCallExpr(singularName: string, pkFieldName: string, argsIdent: string, paramsIdent?: string): t.CallExpression;
+export declare function generateHookFileCode(headerDescription: string, statements: t.Statement[]): string;
+export declare function scopeTypeLiteral(scopeTypeName: string): t.TSTypeLiteral;
+export declare function wrapInferSelectResultType(typeRefNode: CleanArgument['type'], payloadTypeName: string, selectType: t.TSType): t.TSType;
+export declare function typeRefToTsTypeAST(typeRefNode: CleanArgument['type']): t.TSType;
+export declare function buildSelectionArgsCall(selectTypeName: string): t.VariableDeclaration;
+export declare function buildListSelectionArgsCall(selectTypeName: string, filterTypeName: string, orderByTypeName: string): t.VariableDeclaration;
+export declare function customSelectResultTypeLiteral(opName: string, returnType: CleanArgument['type'], payloadTypeName: string, selectType: t.TSType): t.TSTypeLiteral;

package/core/codegen/hooks-ast.js

@@ -0,0 +1,522 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createImportDeclaration = createImportDeclaration;
+exports.createTypeReExport = createTypeReExport;
+exports.typeRef = typeRef;
+exports.sRef = sRef;
+exports.typeofRef = typeofRef;
+exports.stringLiteralType = stringLiteralType;
+exports.inferSelectResultType = inferSelectResultType;
+exports.connectionResultType = connectionResultType;
+exports.typeLiteralWithProps = typeLiteralWithProps;
+exports.queryResultType = queryResultType;
+exports.listQueryResultType = listQueryResultType;
+exports.singleQueryResultType = singleQueryResultType;
+exports.mutationResultType = mutationResultType;
+exports.omitType = omitType;
+exports.listSelectionConfigType = listSelectionConfigType;
+exports.selectionConfigType = selectionConfigType;
+exports.strictSelectType = strictSelectType;
+exports.withFieldsSelectionType = withFieldsSelectionType;
+exports.withFieldsListSelectionType = withFieldsListSelectionType;
+exports.useQueryOptionsType = useQueryOptionsType;
+exports.useQueryOptionsImplType = useQueryOptionsImplType;
+exports.useMutationOptionsType = useMutationOptionsType;
+exports.useMutationResultType = useMutationResultType;
+exports.createSTypeParam = createSTypeParam;
+exports.createSAndTDataTypeParams = createSAndTDataTypeParams;
+exports.createTDataTypeParam = createTDataTypeParam;
+exports.createFunctionParam = createFunctionParam;
+exports.exportDeclareFunction = exportDeclareFunction;
+exports.exportFunction = exportFunction;
+exports.exportAsyncFunction = exportAsyncFunction;
+exports.exportAsyncDeclareFunction = exportAsyncDeclareFunction;
+exports.callExpr = callExpr;
+exports.memberExpr = memberExpr;
+exports.optionalMemberExpr = optionalMemberExpr;
+exports.arrowFn = arrowFn;
+exports.awaitExpr = awaitExpr;
+exports.spreadObj = spreadObj;
+exports.objectProp = objectProp;
+exports.shorthandProp = shorthandProp;
+exports.constDecl = constDecl;
+exports.asConstExpr = asConstExpr;
+exports.asTypeExpr = asTypeExpr;
+exports.voidStatement = voidStatement;
+exports.returnUseQuery = returnUseQuery;
+exports.returnUseMutation = returnUseMutation;
+exports.destructureWithRest = destructureWithRest;
+exports.destructureParamsWithSelection = destructureParamsWithSelection;
+exports.destructureParamsWithSelectionAndScope = destructureParamsWithSelectionAndScope;
+exports.addJSDocComment = addJSDocComment;
+exports.addLineComment = addLineComment;
+exports.getClientCall = getClientCall;
+exports.getClientCallUnwrap = getClientCallUnwrap;
+exports.getClientCustomCall = getClientCustomCall;
+exports.getClientCustomCallUnwrap = getClientCustomCallUnwrap;
+exports.buildFindManyCallExpr = buildFindManyCallExpr;
+exports.buildFindOneCallExpr = buildFindOneCallExpr;
+exports.generateHookFileCode = generateHookFileCode;
+exports.scopeTypeLiteral = scopeTypeLiteral;
+exports.wrapInferSelectResultType = wrapInferSelectResultType;
+exports.typeRefToTsTypeAST = typeRefToTsTypeAST;
+exports.buildSelectionArgsCall = buildSelectionArgsCall;
+exports.buildListSelectionArgsCall = buildListSelectionArgsCall;
+exports.customSelectResultTypeLiteral = customSelectResultTypeLiteral;
+/**
+ * Shared Babel AST helpers for React Query hook generators
+ *
+ * Provides reusable AST-building functions for the common patterns
+ * used across queries.ts, mutations.ts, custom-queries.ts, and custom-mutations.ts.
+ */
+const t = __importStar(require("@babel/types"));
+const babel_ast_1 = require("./babel-ast");
+const type_resolver_1 = require("./type-resolver");
+const utils_1 = require("./utils");
+// ============================================================================
+// Import helpers
+// ============================================================================
+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 createTypeReExport(names, moduleSpecifier) {
+    const specifiers = names.map((name) => t.exportSpecifier(t.identifier(name), t.identifier(name)));
+    const decl = t.exportNamedDeclaration(null, specifiers, t.stringLiteral(moduleSpecifier));
+    decl.exportKind = 'type';
+    return decl;
+}
+// ============================================================================
+// Type reference helpers
+// ============================================================================
+function typeRef(name, params) {
+    return t.tsTypeReference(t.identifier(name), params ? t.tsTypeParameterInstantiation(params) : undefined);
+}
+function sRef() {
+    return typeRef('S');
+}
+function typeofRef(name) {
+    return t.tsTypeQuery(t.identifier(name));
+}
+function stringLiteralType(value) {
+    return t.tsLiteralType(t.stringLiteral(value));
+}
+// ============================================================================
+// Complex type builders
+// ============================================================================
+function inferSelectResultType(entityTypeName, selectType) {
+    return typeRef('InferSelectResult', [typeRef(entityTypeName), selectType]);
+}
+function connectionResultType(entityTypeName, selectType) {
+    return typeRef('ConnectionResult', [
+        inferSelectResultType(entityTypeName, selectType),
+    ]);
+}
+function typeLiteralWithProps(props) {
+    return t.tsTypeLiteral(props.map((p) => {
+        const prop = t.tsPropertySignature(t.identifier(p.name), t.tsTypeAnnotation(p.type));
+        if (p.optional) {
+            prop.optional = true;
+        }
+        return prop;
+    }));
+}
+function queryResultType(queryName, innerType) {
+    return typeLiteralWithProps([{ name: queryName, type: innerType }]);
+}
+function listQueryResultType(queryName, entityTypeName, selectType) {
+    return queryResultType(queryName, connectionResultType(entityTypeName, selectType));
+}
+function singleQueryResultType(queryName, entityTypeName, selectType, nullable = true) {
+    const resultType = inferSelectResultType(entityTypeName, selectType);
+    const innerType = nullable
+        ? t.tsUnionType([resultType, t.tsNullKeyword()])
+        : resultType;
+    return queryResultType(queryName, innerType);
+}
+function mutationResultType(mutationName, entityField, entityTypeName, selectType) {
+    return queryResultType(mutationName, typeLiteralWithProps([
+        {
+            name: entityField,
+            type: inferSelectResultType(entityTypeName, selectType),
+        },
+    ]));
+}
+function omitType(baseType, keys) {
+    const keyType = keys.length === 1
+        ? stringLiteralType(keys[0])
+        : t.tsUnionType(keys.map(stringLiteralType));
+    return typeRef('Omit', [baseType, keyType]);
+}
+function listSelectionConfigType(selectType, filterTypeName, orderByTypeName) {
+    return typeRef('ListSelectionConfig', [
+        selectType,
+        typeRef(filterTypeName),
+        typeRef(orderByTypeName),
+    ]);
+}
+function selectionConfigType(selectType) {
+    return typeRef('SelectionConfig', [selectType]);
+}
+function strictSelectType(selectType, shapeTypeName) {
+    return typeRef('StrictSelect', [selectType, typeRef(shapeTypeName)]);
+}
+function withFieldsSelectionType(selectType, selectTypeName) {
+    return t.tsIntersectionType([
+        typeLiteralWithProps([{ name: 'fields', type: selectType }]),
+        strictSelectType(selectType, selectTypeName),
+    ]);
+}
+function withFieldsListSelectionType(selectType, selectTypeName, filterTypeName, orderByTypeName) {
+    return t.tsIntersectionType([
+        typeLiteralWithProps([{ name: 'fields', type: selectType }]),
+        omitType(listSelectionConfigType(selectType, filterTypeName, orderByTypeName), ['fields']),
+        strictSelectType(selectType, selectTypeName),
+    ]);
+}
+function useQueryOptionsType(queryDataType, dataType, extraProps) {
+    const base = omitType(typeRef('UseQueryOptions', [queryDataType, typeRef('Error'), dataType]), ['queryKey', 'queryFn']);
+    if (extraProps) {
+        return t.tsIntersectionType([base, extraProps]);
+    }
+    return base;
+}
+function useQueryOptionsImplType(extraProps) {
+    const base = omitType(typeRef('UseQueryOptions', [
+        t.tsAnyKeyword(),
+        typeRef('Error'),
+        t.tsAnyKeyword(),
+        t.tsAnyKeyword(),
+    ]), ['queryKey', 'queryFn']);
+    if (extraProps) {
+        return t.tsIntersectionType([base, extraProps]);
+    }
+    return base;
+}
+function useMutationOptionsType(resultType, varType) {
+    return omitType(typeRef('UseMutationOptions', [resultType, typeRef('Error'), varType]), ['mutationFn']);
+}
+function useMutationResultType(resultType, varType) {
+    return typeRef('UseMutationResult', [resultType, typeRef('Error'), varType]);
+}
+// ============================================================================
+// Type parameter helpers
+// ============================================================================
+function createSTypeParam(constraintName) {
+    const param = t.tsTypeParameter(typeRef(constraintName), null, 'S');
+    return t.tsTypeParameterDeclaration([param]);
+}
+function createSAndTDataTypeParams(constraintName, defaultDataType) {
+    const sParam = t.tsTypeParameter(typeRef(constraintName), null, 'S');
+    const tDataParam = t.tsTypeParameter(null, defaultDataType, 'TData');
+    return t.tsTypeParameterDeclaration([sParam, tDataParam]);
+}
+function createTDataTypeParam(defaultType) {
+    const param = t.tsTypeParameter(null, defaultType, 'TData');
+    return t.tsTypeParameterDeclaration([param]);
+}
+// ============================================================================
+// Function declaration helpers
+// ============================================================================
+function createFunctionParam(name, typeAnnotation, optional = false) {
+    const param = t.identifier(name);
+    param.typeAnnotation = t.tsTypeAnnotation(typeAnnotation);
+    param.optional = optional;
+    return param;
+}
+function exportDeclareFunction(name, typeParameters, params, returnType) {
+    const func = t.tsDeclareFunction(t.identifier(name), typeParameters, params, t.tsTypeAnnotation(returnType));
+    return t.exportNamedDeclaration(func);
+}
+function exportFunction(name, typeParameters, params, body, returnType) {
+    const func = t.functionDeclaration(t.identifier(name), params, t.blockStatement(body));
+    func.typeParameters = typeParameters;
+    if (returnType) {
+        func.returnType = t.tsTypeAnnotation(returnType);
+    }
+    return t.exportNamedDeclaration(func);
+}
+function exportAsyncFunction(name, typeParameters, params, body, returnType) {
+    const func = t.functionDeclaration(t.identifier(name), params, t.blockStatement(body));
+    func.async = true;
+    func.typeParameters = typeParameters;
+    if (returnType) {
+        func.returnType = t.tsTypeAnnotation(returnType);
+    }
+    return t.exportNamedDeclaration(func);
+}
+function exportAsyncDeclareFunction(name, typeParameters, params, returnType) {
+    const func = t.tsDeclareFunction(t.identifier(name), typeParameters, params, t.tsTypeAnnotation(returnType));
+    func.async = true;
+    return t.exportNamedDeclaration(func);
+}
+// ============================================================================
+// Expression helpers
+// ============================================================================
+function callExpr(callee, args) {
+    const calleeExpr = typeof callee === 'string' ? t.identifier(callee) : callee;
+    return t.callExpression(calleeExpr, args);
+}
+function memberExpr(obj, prop) {
+    return t.memberExpression(t.identifier(obj), t.identifier(prop));
+}
+function optionalMemberExpr(obj, prop) {
+    return t.optionalMemberExpression(t.identifier(obj), t.identifier(prop), false, true);
+}
+function arrowFn(params, body) {
+    return t.arrowFunctionExpression(params, body);
+}
+function awaitExpr(expr) {
+    return t.awaitExpression(expr);
+}
+function spreadObj(expr) {
+    return t.spreadElement(expr);
+}
+function objectProp(key, value, shorthand = false) {
+    return t.objectProperty(t.identifier(key), value, false, shorthand);
+}
+function shorthandProp(name) {
+    return t.objectProperty(t.identifier(name), t.identifier(name), false, true);
+}
+function constDecl(name, init) {
+    return t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier(name), init),
+    ]);
+}
+function asConstExpr(expr) {
+    return t.tsAsExpression(expr, t.tsTypeReference(t.identifier('const')));
+}
+function asTypeExpr(expr, typeName) {
+    return t.tsAsExpression(expr, typeRef(typeName));
+}
+// ============================================================================
+// Statement helpers
+// ============================================================================
+function voidStatement(name) {
+    return t.expressionStatement(t.unaryExpression('void', t.identifier(name)));
+}
+function returnUseQuery(queryKeyExpr, queryFnExpr, extraProps, enabledExpr) {
+    const props = [
+        objectProp('queryKey', queryKeyExpr),
+        objectProp('queryFn', queryFnExpr),
+    ];
+    if (enabledExpr) {
+        props.push(objectProp('enabled', enabledExpr));
+    }
+    if (extraProps) {
+        props.push(...extraProps);
+    }
+    return t.returnStatement(callExpr('useQuery', [t.objectExpression(props)]));
+}
+function returnUseMutation(mutationFnExpr, extraProps, mutationKeyExpr) {
+    const props = [];
+    if (mutationKeyExpr) {
+        props.push(objectProp('mutationKey', mutationKeyExpr));
+    }
+    props.push(objectProp('mutationFn', mutationFnExpr));
+    props.push(...extraProps);
+    return t.returnStatement(callExpr('useMutation', [t.objectExpression(props)]));
+}
+// ============================================================================
+// Destructuring helpers
+// ============================================================================
+function destructureWithRest(source, keys, restName) {
+    const properties = keys.map((key) => t.objectProperty(t.identifier(key), t.identifier(`_${key}`), false, false));
+    const pattern = t.objectPattern([
+        ...properties,
+        t.restElement(t.identifier(restName)),
+    ]);
+    return constDecl(restName, t.identifier('__placeholder__'));
+}
+function destructureParamsWithSelection(restName, extraKeys = []) {
+    const properties = [];
+    for (const key of extraKeys) {
+        properties.push(t.objectProperty(t.identifier(key), t.identifier(key), false, true));
+    }
+    properties.push(t.objectProperty(t.identifier('selection'), t.identifier('_selection'), false, false));
+    properties.push(t.restElement(t.identifier(restName)));
+    const pattern = t.objectPattern(properties);
+    return t.variableDeclaration('const', [
+        t.variableDeclarator(pattern, t.logicalExpression('??', t.identifier('params'), t.objectExpression([]))),
+    ]);
+}
+function destructureParamsWithSelectionAndScope(restName) {
+    const pattern = t.objectPattern([
+        t.objectProperty(t.identifier('scope'), t.identifier('scope'), false, true),
+        t.objectProperty(t.identifier('selection'), t.identifier('_selection'), false, false),
+        t.restElement(t.identifier(restName)),
+    ]);
+    return t.variableDeclaration('const', [
+        t.variableDeclarator(pattern, t.logicalExpression('??', t.identifier('params'), t.objectExpression([]))),
+    ]);
+}
+// ============================================================================
+// JSDoc comment helpers
+// ============================================================================
+function addJSDocComment(node, lines) {
+    const text = lines.length === 1
+        ? `* ${lines[0]} `
+        : `*\n${lines.map((line) => ` * ${line}`).join('\n')}\n `;
+    if (!node.leadingComments) {
+        node.leadingComments = [];
+    }
+    node.leadingComments.push((0, babel_ast_1.commentBlock)(text));
+    return node;
+}
+function addLineComment(node, text) {
+    if (!node.leadingComments) {
+        node.leadingComments = [];
+    }
+    node.leadingComments.push({
+        type: 'CommentLine',
+        value: ` ${text}`,
+        start: null,
+        end: null,
+        loc: null,
+    });
+    return node;
+}
+// ============================================================================
+// ORM client call builders
+// ============================================================================
+function getClientCall(modelName, method, args) {
+    return t.callExpression(t.memberExpression(t.memberExpression(callExpr('getClient', []), t.identifier(modelName)), t.identifier(method)), [args]);
+}
+function getClientCallUnwrap(modelName, method, args) {
+    return t.callExpression(t.memberExpression(getClientCall(modelName, method, args), t.identifier('unwrap')), []);
+}
+function getClientCustomCall(operationType, operationName, args, optionsArg) {
+    const callArgs = optionsArg ? [...args, optionsArg] : args;
+    return t.callExpression(t.memberExpression(t.memberExpression(callExpr('getClient', []), t.identifier(operationType)), t.identifier(operationName)), callArgs);
+}
+function getClientCustomCallUnwrap(operationType, operationName, args, optionsArg) {
+    return t.callExpression(t.memberExpression(getClientCustomCall(operationType, operationName, args, optionsArg), t.identifier('unwrap')), []);
+}
+// ============================================================================
+// Select/args expression builders
+// ============================================================================
+function buildFindManyCallExpr(singularName, argsIdent) {
+    return getClientCallUnwrap(singularName, 'findMany', t.identifier(argsIdent));
+}
+function buildFindOneCallExpr(singularName, pkFieldName, argsIdent, paramsIdent = 'params') {
+    return getClientCallUnwrap(singularName, 'findOne', t.objectExpression([
+        objectProp(pkFieldName, t.memberExpression(t.identifier(paramsIdent), t.identifier(pkFieldName))),
+        objectProp('select', t.memberExpression(t.identifier(argsIdent), t.identifier('select'))),
+    ]));
+}
+// ============================================================================
+// Code generation
+// ============================================================================
+function generateHookFileCode(headerDescription, statements) {
+    const header = (0, utils_1.getGeneratedFileHeader)(headerDescription);
+    const code = (0, babel_ast_1.generateCode)(statements);
+    return header + '\n\n' + code + '\n';
+}
+// ============================================================================
+// Scope type helper
+// ============================================================================
+function scopeTypeLiteral(scopeTypeName) {
+    return typeLiteralWithProps([
+        {
+            name: 'scope',
+            type: typeRef(scopeTypeName),
+            optional: true,
+        },
+    ]);
+}
+// ============================================================================
+// Type conversion helpers (GraphQL -> AST)
+// ============================================================================
+function wrapInferSelectResultType(typeRefNode, payloadTypeName, selectType) {
+    if (typeRefNode.kind === 'NON_NULL' && typeRefNode.ofType) {
+        return wrapInferSelectResultType(typeRefNode.ofType, payloadTypeName, selectType);
+    }
+    if (typeRefNode.kind === 'LIST' && typeRefNode.ofType) {
+        return t.tsArrayType(wrapInferSelectResultType(typeRefNode.ofType, payloadTypeName, selectType));
+    }
+    return inferSelectResultType(payloadTypeName, selectType);
+}
+function typeRefToTsTypeAST(typeRefNode) {
+    if (typeRefNode.kind === 'NON_NULL' && typeRefNode.ofType) {
+        return typeRefToTsTypeAST(typeRefNode.ofType);
+    }
+    if (typeRefNode.kind === 'LIST' && typeRefNode.ofType) {
+        return t.tsArrayType(typeRefToTsTypeAST(typeRefNode.ofType));
+    }
+    if (typeRefNode.kind === 'SCALAR') {
+        const tsType = (0, type_resolver_1.scalarToTsType)(typeRefNode.name ?? 'unknown');
+        if (tsType === 'string')
+            return t.tsStringKeyword();
+        if (tsType === 'number')
+            return t.tsNumberKeyword();
+        if (tsType === 'boolean')
+            return t.tsBooleanKeyword();
+        return t.tsUnknownKeyword();
+    }
+    return typeRef(typeRefNode.name ?? 'unknown');
+}
+function buildSelectionArgsCall(selectTypeName) {
+    const call = t.callExpression(t.identifier('buildSelectionArgs'), [
+        t.memberExpression(t.identifier('params'), t.identifier('selection')),
+    ]);
+    // @ts-ignore - Babel types support typeParameters on CallExpression for TS
+    call.typeParameters = t.tsTypeParameterInstantiation([
+        typeRef(selectTypeName),
+    ]);
+    return constDecl('args', call);
+}
+function buildListSelectionArgsCall(selectTypeName, filterTypeName, orderByTypeName) {
+    const call = t.callExpression(t.identifier('buildListSelectionArgs'), [
+        t.memberExpression(t.identifier('params'), t.identifier('selection')),
+    ]);
+    // @ts-ignore - Babel types support typeParameters on CallExpression for TS
+    call.typeParameters = t.tsTypeParameterInstantiation([
+        typeRef(selectTypeName),
+        typeRef(filterTypeName),
+        typeRef(orderByTypeName),
+    ]);
+    return constDecl('args', call);
+}
+function customSelectResultTypeLiteral(opName, returnType, payloadTypeName, selectType) {
+    return typeLiteralWithProps([
+        {
+            name: opName,
+            type: wrapInferSelectResultType(returnType, payloadTypeName, selectType),
+        },
+    ]);
+}

package/core/codegen/index.d.ts

@@ -2,29 +2,28 @@
  * Code generation orchestrator
  *
  * Coordinates all code generators to produce the complete SDK output.
+ * Hooks delegate to ORM model methods - types are imported from ORM's input-types.ts.
  *
  * Output structure:
  * generated/
  *   index.ts              - Main barrel export
- *   client.ts             - GraphQL client with configure() and execute()
- *   types.ts              - Entity interfaces and filter types
+ *   client.ts             - ORM client wrapper (configure/getClient)
  *   queries/
  *     index.ts            - Query hooks barrel
- *     useCarsQuery.ts     - List query hook (table-based)
- *     useCarQuery.ts      - Single item query hook (table-based)
- *     useCurrentUserQuery.ts - Custom query hook
+ *     useCarsQuery.ts     - List query hook -> ORM findMany
+ *     useCarQuery.ts      - Single item query hook -> ORM findOne
+ *     useCurrentUserQuery.ts - Custom query hook -> ORM query.xxx
  *     ...
  *   mutations/
  *     index.ts            - Mutation hooks barrel
- *     useCreateCarMutation.ts  - Table-based CRUD
- *     useUpdateCarMutation.ts
- *     useDeleteCarMutation.ts
- *     useLoginMutation.ts      - Custom mutation
- *     useRegisterMutation.ts
+ *     useCreateCarMutation.ts  - -> ORM create
+ *     useUpdateCarMutation.ts  - -> ORM update
+ *     useDeleteCarMutation.ts  - -> ORM delete
+ *     useLoginMutation.ts      - Custom mutation -> ORM mutation.xxx
  *     ...
  */
-import type { CleanTable, CleanOperation, TypeRegistry } from '../../types/schema';
 import type { GraphQLSDKConfigTarget } from '../../types/config';
+import type { CleanOperation, CleanTable, TypeRegistry } from '../../types/schema';
 export interface GeneratedFile {
     /** Relative path from output directory */
     path: string;
@@ -72,13 +71,12 @@ export declare function generateAllFiles(tables: CleanTable[], config: GraphQLSD
  * (they're expected to exist in the shared types directory).
  */
 export declare function generate(options: GenerateOptions): GenerateResult;
+export { generateCustomMutationsBarrel, generateCustomQueriesBarrel, generateMainBarrel, generateMutationsBarrel, generateQueriesBarrel, } from './barrel';
 export { generateClientFile } from './client';
-export { generateTypesFile } from './types';
-export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook, } from './queries';
-export { generateAllMutationHooks, generateCreateMutationHook, generateUpdateMutationHook, generateDeleteMutationHook, } from './mutations';
-export { generateAllCustomQueryHooks, generateCustomQueryHook, } from './custom-queries';
 export { generateAllCustomMutationHooks, generateCustomMutationHook, } from './custom-mutations';
-export { generateQueriesBarrel, generateMutationsBarrel, generateMainBarrel, generateCustomQueriesBarrel, generateCustomMutationsBarrel, } from './barrel';
-export { generateQueryKeysFile } from './query-keys';
-export { generateMutationKeysFile } from './mutation-keys';
+export { generateAllCustomQueryHooks, generateCustomQueryHook, } from './custom-queries';
 export { generateInvalidationFile } from './invalidation';
+export { generateMutationKeysFile } from './mutation-keys';
+export { generateAllMutationHooks, generateCreateMutationHook, generateDeleteMutationHook, generateUpdateMutationHook, } from './mutations';
+export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook, } from './queries';
+export { generateQueryKeysFile } from './query-keys';