@constructive-io/graphql-codegen 3.3.1 → 4.0.0

package/esm/core/codegen/custom-mutations.js

@@ -14,7 +14,7 @@
  *   ...
  */
 import * as t from '@babel/types';
-import { buildSelectionArgsCall, callExpr, constDecl, createFunctionParam, createImportDeclaration, createSTypeParam, createTypeReExport, customSelectResultTypeLiteral, destructureParamsWithSelection, exportDeclareFunction, exportFunction, generateHookFileCode, getClientCustomCallUnwrap, objectProp, omitType, returnUseMutation, selectionConfigType, spreadObj, sRef, typeRef, useMutationOptionsType, useMutationResultType, voidStatement, } from './hooks-ast';
+import { buildSelectionArgsCall, callExpr, constDecl, createFunctionParam, createImportDeclaration, createSTypeParam, createTypeReExport, customSelectResultTypeLiteral, destructureParamsWithSelection, exportFunction, generateHookFileCode, getClientCustomCallUnwrap, objectProp, omitType, returnUseMutation, spreadObj, sRef, typeRef, typeRefToTsTypeAST, useMutationOptionsType, useMutationResultType, voidStatement, } from './hooks-ast';
 import { getSelectTypeName } from './select-helpers';
 import { createTypeTracker, getOperationFileName, getOperationHookName, getTypeBaseName, typeRefToTsType, } from './type-resolver';
 import { ucFirst } from './utils';
@@ -75,7 +75,7 @@ function generateCustomMutationHookInternal(options) {
         statements.push(createImportDeclaration('../../orm/input-types', inputTypeImports, true));
     }
     if (hasSelect) {
-        statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'StrictSelect'], true));
+        statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'HookStrictSelect', 'StrictSelect'], true));
     }
     // Re-exports
     if (hasArgs) {
@@ -90,39 +90,38 @@ function generateCustomMutationHookInternal(options) {
             ? typeRef(varTypeName)
             : t.tsVoidKeyword();
         const selectedResultType = (sel) => customSelectResultTypeLiteral(operation.name, operation.returnType, payloadTypeName, sel);
-        // Overload 1: with selection.fields
-        const o1ParamType = t.tsIntersectionType([
+        const paramsType = t.tsIntersectionType([
             t.tsTypeLiteral([
                 t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(t.tsParenthesizedType(t.tsIntersectionType([
                     t.tsTypeLiteral([
-                        t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(sRef())),
+                        t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(t.tsIntersectionType([sRef(), typeRef(selectTypeName)]))),
+                    ]),
+                    typeRef('HookStrictSelect', [
+                        typeRef('NoInfer', [sRef()]),
+                        typeRef(selectTypeName),
                     ]),
-                    typeRef('StrictSelect', [sRef(), typeRef(selectTypeName)]),
                 ])))),
             ]),
             useMutationOptionsType(selectedResultType(sRef()), mutationVarType),
         ]);
-        statements.push(exportDeclareFunction(hookName, createSTypeParam(selectTypeName), [createFunctionParam('params', o1ParamType)], useMutationResultType(selectedResultType(sRef()), mutationVarType)));
-        // Implementation
-        const implSelProp = t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(selectionConfigType(typeRef(selectTypeName))));
-        const implParamType = t.tsIntersectionType([
-            t.tsTypeLiteral([implSelProp]),
-            omitType(typeRef('UseMutationOptions', [
-                t.tsAnyKeyword(),
-                typeRef('Error'),
-                mutationVarType,
-            ]), ['mutationFn']),
-        ]);
         const body = [];
-        body.push(buildSelectionArgsCall(selectTypeName));
+        body.push(buildSelectionArgsCall(sRef()));
         body.push(destructureParamsWithSelection('mutationOptions'));
         body.push(voidStatement('_selection'));
         const mutationKeyExpr = useCentralizedKeys
             ? callExpr(t.memberExpression(t.identifier('customMutationKeys'), t.identifier(operation.name)), [])
             : undefined;
-        const selectArgExpr = t.objectExpression([
+        // Cast to ORM's StrictSelect (not HookStrictSelect) since the ORM
+        // method signature requires { select: S } & StrictSelect<S, XxxSelect>.
+        // Strictness is already enforced at the hook parameter level.
+        const selectArgExpr = t.tsAsExpression(t.objectExpression([
             objectProp('select', t.memberExpression(t.identifier('args'), t.identifier('select'))),
-        ]);
+        ]), t.tsIntersectionType([
+            t.tsTypeLiteral([
+                t.tsPropertySignature(t.identifier('select'), t.tsTypeAnnotation(sRef())),
+            ]),
+            typeRef('StrictSelect', [sRef(), typeRef(selectTypeName)]),
+        ]));
         let mutationFnExpr;
         if (hasArgs) {
             const variablesParam = createFunctionParam('variables', typeRef(varTypeName));
@@ -132,13 +131,14 @@ function generateCustomMutationHookInternal(options) {
             mutationFnExpr = t.arrowFunctionExpression([], getClientCustomCallUnwrap('mutation', operation.name, [], selectArgExpr));
         }
         body.push(returnUseMutation(mutationFnExpr, [spreadObj(t.identifier('mutationOptions'))], mutationKeyExpr));
-        statements.push(exportFunction(hookName, null, [createFunctionParam('params', implParamType)], body));
+        statements.push(exportFunction(hookName, createSTypeParam(selectTypeName), [createFunctionParam('params', paramsType)], body, useMutationResultType(selectedResultType(sRef()), mutationVarType)));
     }
     else {
         // Without select: simple hook (scalar return type)
-        const resultTypeStr = typeRefToTsType(operation.returnType, tracker);
+        typeRefToTsType(operation.returnType, tracker);
+        const resultTsType = typeRefToTsTypeAST(operation.returnType);
         const resultTypeLiteral = t.tsTypeLiteral([
-            t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(typeRef(resultTypeStr))),
+            t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(resultTsType)),
         ]);
         const mutationVarType = hasArgs
             ? typeRef(varTypeName)

package/esm/core/codegen/custom-queries.js

@@ -15,7 +15,7 @@
  */
 import * as t from '@babel/types';
 import { asConst } from './babel-ast';
-import { addJSDocComment, buildSelectionArgsCall, callExpr, constDecl, createFunctionParam, createImportDeclaration, createSAndTDataTypeParams, createSTypeParam, createTDataTypeParam, createTypeReExport, customSelectResultTypeLiteral, destructureParamsWithSelection, exportAsyncDeclareFunction, exportAsyncFunction, exportDeclareFunction, exportFunction, generateHookFileCode, getClientCustomCallUnwrap, objectProp, omitType, returnUseQuery, selectionConfigType, spreadObj, sRef, typeRef, useQueryOptionsImplType, voidStatement, } from './hooks-ast';
+import { addJSDocComment, buildSelectionArgsCall, callExpr, constDecl, createFunctionParam, createImportDeclaration, createSAndTDataTypeParams, createSTypeParam, createTDataTypeParam, createTypeReExport, customSelectResultTypeLiteral, destructureParamsWithSelection, exportAsyncDeclareFunction, exportAsyncFunction, exportDeclareFunction, exportFunction, generateHookFileCode, getClientCustomCallUnwrap, objectProp, omitType, returnUseQuery, selectionConfigType, spreadObj, sRef, typeRef, typeRefToTsTypeAST, useQueryOptionsImplType, voidStatement, } from './hooks-ast';
 import { getSelectTypeName } from './select-helpers';
 import { createTypeTracker, getOperationFileName, getOperationHookName, getQueryKeyName, getTypeBaseName, isTypeRequired, typeRefToTsType, } from './type-resolver';
 import { ucFirst } from './utils';
@@ -28,10 +28,11 @@ export function generateCustomQueryHook(options) {
     const tracker = createTypeTracker({ tableTypeNames });
     const hasArgs = operation.args.length > 0;
     const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
-    const resultType = typeRefToTsType(operation.returnType, tracker);
+    typeRefToTsType(operation.returnType, tracker);
     for (const arg of operation.args) {
         typeRefToTsType(arg.type, tracker);
     }
+    const resultTsType = typeRefToTsTypeAST(operation.returnType);
     const selectTypeName = getSelectTypeName(operation.returnType);
     const payloadTypeName = getTypeBaseName(operation.returnType);
     const hasSelect = !!selectTypeName && !!payloadTypeName;
@@ -69,7 +70,7 @@ export function generateCustomQueryHook(options) {
         statements.push(createImportDeclaration('../../orm/input-types', inputTypeImports, true));
     }
     if (hasSelect) {
-        statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'StrictSelect'], true));
+        statements.push(createImportDeclaration('../../orm/select-types', ['InferSelectResult', 'HookStrictSelect'], true));
     }
     // Re-exports
     if (hasArgs) {
@@ -121,9 +122,12 @@ export function generateCustomQueryHook(options) {
     // Helper to build the fields+StrictSelect intersection type
     const fieldsSelectionType = (s) => t.tsParenthesizedType(t.tsIntersectionType([
         t.tsTypeLiteral([
-            t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(s)),
+            t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(t.tsIntersectionType([s, typeRef(selectTypeName)]))),
+        ]),
+        typeRef('HookStrictSelect', [
+            typeRef('NoInfer', [s]),
+            typeRef(selectTypeName),
         ]),
-        typeRef('StrictSelect', [s, typeRef(selectTypeName)]),
     ]));
     const selectedResultType = (sel) => customSelectResultTypeLiteral(operation.name, operation.returnType, payloadTypeName, sel);
     // Hook
@@ -141,10 +145,11 @@ export function generateCustomQueryHook(options) {
             // Overload 1: with selection.fields
             const o1Props = [];
             if (hasArgs) {
-                const varType = hasRequiredArgs
-                    ? typeRef(varTypeName)
-                    : t.tsUnionType([typeRef(varTypeName), t.tsUndefinedKeyword()]);
-                o1Props.push(t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(varType)));
+                const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+                if (!hasRequiredArgs) {
+                    varProp.optional = true;
+                }
+                o1Props.push(varProp);
             }
             o1Props.push(t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(fieldsSelectionType(sRef()))));
             const o1ParamType = t.tsIntersectionType([
@@ -230,7 +235,7 @@ export function generateCustomQueryHook(options) {
         else {
             // Without select: simple hook (scalar return type)
             const resultTypeLiteral = t.tsTypeLiteral([
-                t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(typeRef(resultType))),
+                t.tsPropertySignature(t.identifier(operation.name), t.tsTypeAnnotation(resultTsType)),
             ]);
             const optType = omitType(typeRef('UseQueryOptions', [
                 resultTypeLiteral,
@@ -309,10 +314,11 @@ export function generateCustomQueryHook(options) {
         // Overload 1: with fields
         const f1Props = [];
         if (hasArgs) {
-            const varType = hasRequiredArgs
-                ? typeRef(varTypeName)
-                : t.tsUnionType([typeRef(varTypeName), t.tsUndefinedKeyword()]);
-            f1Props.push(t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(varType)));
+            const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+            if (!hasRequiredArgs) {
+                varProp.optional = true;
+            }
+            f1Props.push(varProp);
         }
         f1Props.push(t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(fieldsSelectionType(sRef()))));
         const f1Decl = exportAsyncDeclareFunction(fetchFnName, createSTypeParam(selectTypeName), [createFunctionParam('params', t.tsTypeLiteral(f1Props))], typeRef('Promise', [selectedResultType(sRef())]));
@@ -415,10 +421,11 @@ export function generateCustomQueryHook(options) {
             // Overload 1: with fields
             const p1Props = [];
             if (hasArgs) {
-                const varType = hasRequiredArgs
-                    ? typeRef(varTypeName)
-                    : t.tsUnionType([typeRef(varTypeName), t.tsUndefinedKeyword()]);
-                p1Props.push(t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(varType)));
+                const varProp = t.tsPropertySignature(t.identifier('variables'), t.tsTypeAnnotation(typeRef(varTypeName)));
+                if (!hasRequiredArgs) {
+                    varProp.optional = true;
+                }
+                p1Props.push(varProp);
             }
             p1Props.push(t.tsPropertySignature(t.identifier('selection'), t.tsTypeAnnotation(fieldsSelectionType(sRef()))));
             const p1Decl = exportAsyncDeclareFunction(prefetchFnName, createSTypeParam(selectTypeName), [

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

@@ -70,6 +70,6 @@ export declare function generateHookFileCode(headerDescription: string, statemen
 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 buildSelectionArgsCall(selectType: string | t.TSType): 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/esm/core/codegen/hooks-ast.js

@@ -96,7 +96,10 @@ export function selectionConfigType(selectType) {
     return typeRef('SelectionConfig', [selectType]);
 }
 export function strictSelectType(selectType, shapeTypeName) {
-    return typeRef('StrictSelect', [selectType, typeRef(shapeTypeName)]);
+    return typeRef('HookStrictSelect', [
+        typeRef('NoInfer', [selectType]),
+        typeRef(shapeTypeName),
+    ]);
 }
 export function withFieldsSelectionType(selectType, selectTypeName) {
     return t.tsIntersectionType([
@@ -365,8 +368,15 @@ export function scopeTypeLiteral(scopeTypeName) {
 // Type conversion helpers (GraphQL -> AST)
 // ============================================================================
 export function wrapInferSelectResultType(typeRefNode, payloadTypeName, selectType) {
+    const nonNullable = wrapInferSelectResultTypeNonNullable(typeRefNode, payloadTypeName, selectType);
+    if (typeRefNode.kind === 'NON_NULL') {
+        return nonNullable;
+    }
+    return t.tsUnionType([nonNullable, t.tsNullKeyword()]);
+}
+function wrapInferSelectResultTypeNonNullable(typeRefNode, payloadTypeName, selectType) {
     if (typeRefNode.kind === 'NON_NULL' && typeRefNode.ofType) {
-        return wrapInferSelectResultType(typeRefNode.ofType, payloadTypeName, selectType);
+        return wrapInferSelectResultTypeNonNullable(typeRefNode.ofType, payloadTypeName, selectType);
     }
     if (typeRefNode.kind === 'LIST' && typeRefNode.ofType) {
         return t.tsArrayType(wrapInferSelectResultType(typeRefNode.ofType, payloadTypeName, selectType));
@@ -374,8 +384,15 @@ export function wrapInferSelectResultType(typeRefNode, payloadTypeName, selectTy
     return inferSelectResultType(payloadTypeName, selectType);
 }
 export function typeRefToTsTypeAST(typeRefNode) {
+    const nonNullable = typeRefToTsTypeASTNonNullable(typeRefNode);
+    if (typeRefNode.kind === 'NON_NULL') {
+        return nonNullable;
+    }
+    return t.tsUnionType([nonNullable, t.tsNullKeyword()]);
+}
+function typeRefToTsTypeASTNonNullable(typeRefNode) {
     if (typeRefNode.kind === 'NON_NULL' && typeRefNode.ofType) {
-        return typeRefToTsTypeAST(typeRefNode.ofType);
+        return typeRefToTsTypeASTNonNullable(typeRefNode.ofType);
     }
     if (typeRefNode.kind === 'LIST' && typeRefNode.ofType) {
         return t.tsArrayType(typeRefToTsTypeAST(typeRefNode.ofType));
@@ -392,13 +409,13 @@ export function typeRefToTsTypeAST(typeRefNode) {
     }
     return typeRef(typeRefNode.name ?? 'unknown');
 }
-export function buildSelectionArgsCall(selectTypeName) {
+export function buildSelectionArgsCall(selectType) {
     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),
+        typeof selectType === 'string' ? typeRef(selectType) : selectType,
     ]);
     return constDecl('args', call);
 }

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

@@ -42,7 +42,7 @@ export interface GenerateResult {
     };
 }
 export interface GenerateOptions {
-    /** Tables from _meta introspection */
+    /** Tables from GraphQL introspection */
     tables: CleanTable[];
     /** Custom operations from __schema introspection */
     customOperations?: {

package/esm/core/codegen/mutations.js

@@ -26,9 +26,12 @@ function buildMutationResultType(mutationName, singularName, relationTypeName, s
 function buildFieldsSelectionType(s, selectTypeName) {
     return t.tsParenthesizedType(t.tsIntersectionType([
         t.tsTypeLiteral([
-            t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(s)),
+            t.tsPropertySignature(t.identifier('fields'), t.tsTypeAnnotation(t.tsIntersectionType([s, typeRef(selectTypeName)]))),
+        ]),
+        typeRef('HookStrictSelect', [
+            typeRef('NoInfer', [s]),
+            typeRef(selectTypeName),
         ]),
-        typeRef('StrictSelect', [s, typeRef(selectTypeName)]),
     ]));
 }
 export function generateCreateMutationHook(table, options = {}) {
@@ -58,7 +61,7 @@ export function generateCreateMutationHook(table, options = {}) {
         statements.push(createImportDeclaration('../mutation-keys', [mutationKeysName]));
     }
     statements.push(createImportDeclaration('../../orm/input-types', [selectTypeName, relationTypeName, createInputTypeName], 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, createInputTypeName], '../../orm/input-types'));
     // Variable type: CreateTypeName['singularName']
@@ -147,6 +150,7 @@ export function generateUpdateMutationHook(table, options = {}) {
     const patchTypeName = `${typeName}Patch`;
     const pkFields = getPrimaryKeyInfo(table);
     const pkField = pkFields[0];
+    const patchFieldName = table.query?.patchFieldName ?? lcFirst(typeName) + 'Patch';
     const pkTsType = pkField.tsType === 'string' ? t.tsStringKeyword() : t.tsNumberKeyword();
     const statements = [];
     // Imports
@@ -163,13 +167,13 @@ export function generateUpdateMutationHook(table, options = {}) {
         statements.push(createImportDeclaration('../mutation-keys', [mutationKeysName]));
     }
     statements.push(createImportDeclaration('../../orm/input-types', [selectTypeName, relationTypeName, patchTypeName], 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, patchTypeName], '../../orm/input-types'));
-    // Variable type: { pkField: type; patch: PatchType }
+    // Variable type: { pkField: type; patchFieldName: PatchType }
     const updateVarType = t.tsTypeLiteral([
         t.tsPropertySignature(t.identifier(pkField.name), t.tsTypeAnnotation(pkTsType)),
-        t.tsPropertySignature(t.identifier('patch'), t.tsTypeAnnotation(typeRef(patchTypeName))),
+        t.tsPropertySignature(t.identifier(patchFieldName), t.tsTypeAnnotation(typeRef(patchTypeName))),
     ]);
     const resultType = (sel) => buildMutationResultType(mutationName, singularName, relationTypeName, sel);
     // Overload 1: with fields
@@ -189,7 +193,7 @@ export function generateUpdateMutationHook(table, options = {}) {
         '  selection: { fields: { id: true, name: true } },',
         '});',
         '',
-        `mutate({ ${pkField.name}: 'value-here', patch: { name: 'Updated' } });`,
+        `mutate({ ${pkField.name}: 'value-here', ${patchFieldName}: { name: 'Updated' } });`,
         '```',
     ]);
     statements.push(o1);
@@ -211,16 +215,16 @@ export function generateUpdateMutationHook(table, options = {}) {
     const mutationKeyExpr = useCentralizedKeys
         ? t.memberExpression(t.identifier(mutationKeysName), t.identifier('all'))
         : undefined;
-    // mutationFn: ({ pkField, patch }: { pkField: type; patch: PatchType }) =>
-    //   getClient().singular.update({ where: { pkField }, data: patch, select: ... }).unwrap()
+    // mutationFn: ({ pkField, patchFieldName }: VarType) =>
+    //   getClient().singular.update({ where: { pkField }, data: patchFieldName, select: ... }).unwrap()
     const destructParam = t.objectPattern([
         shorthandProp(pkField.name),
-        shorthandProp('patch'),
+        shorthandProp(patchFieldName),
     ]);
     destructParam.typeAnnotation = t.tsTypeAnnotation(updateVarType);
     const mutationFnExpr = t.arrowFunctionExpression([destructParam], getClientCallUnwrap(singularName, 'update', t.objectExpression([
         objectProp('where', t.objectExpression([shorthandProp(pkField.name)])),
-        objectProp('data', t.identifier('patch')),
+        objectProp('data', t.identifier(patchFieldName)),
         objectProp('select', t.memberExpression(t.identifier('args'), t.identifier('select'))),
     ])));
     // onSuccess: invalidate detail and lists
@@ -288,7 +292,7 @@ export function generateDeleteMutationHook(table, options = {}) {
         statements.push(createImportDeclaration('../mutation-keys', [mutationKeysName]));
     }
     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'));
     // Variable type: { pkField: type }

package/esm/core/codegen/orm/custom-ops-generator.js

@@ -7,7 +7,7 @@
 import * as t from '@babel/types';
 import { generateCode } from '../babel-ast';
 import { NON_SELECT_TYPES, getSelectTypeName } from '../select-helpers';
-import { getTypeBaseName, isTypeRequired, typeRefToTsType, } from '../type-resolver';
+import { getTypeBaseName, isTypeRequired, scalarToTsType, typeRefToTsType, } from '../type-resolver';
 import { getGeneratedFileHeader, ucFirst } from '../utils';
 /**
  * Collect all input type names used by operations
@@ -105,8 +105,15 @@ function parseTypeAnnotation(typeStr) {
     return t.tsTypeReference(t.identifier(typeStr));
 }
 function buildSelectedResultTsType(typeRef, payloadTypeName) {
+    const nonNullable = buildSelectedResultTsTypeNonNullable(typeRef, payloadTypeName);
+    if (typeRef.kind === 'NON_NULL') {
+        return nonNullable;
+    }
+    return t.tsUnionType([nonNullable, t.tsNullKeyword()]);
+}
+function buildSelectedResultTsTypeNonNullable(typeRef, payloadTypeName) {
     if (typeRef.kind === 'NON_NULL' && typeRef.ofType) {
-        return buildSelectedResultTsType(typeRef.ofType, payloadTypeName);
+        return buildSelectedResultTsTypeNonNullable(typeRef.ofType, payloadTypeName);
     }
     if (typeRef.kind === 'LIST' && typeRef.ofType) {
         return t.tsArrayType(buildSelectedResultTsType(typeRef.ofType, payloadTypeName));
@@ -116,6 +123,34 @@ function buildSelectedResultTsType(typeRef, payloadTypeName) {
         t.tsTypeReference(t.identifier('S')),
     ]));
 }
+function scalarTsTypeToAst(typeName) {
+    if (typeName === 'string')
+        return t.tsStringKeyword();
+    if (typeName === 'number')
+        return t.tsNumberKeyword();
+    if (typeName === 'boolean')
+        return t.tsBooleanKeyword();
+    return t.tsUnknownKeyword();
+}
+function buildRawResultTsType(typeRef) {
+    const nonNullable = buildRawResultTsTypeNonNullable(typeRef);
+    if (typeRef.kind === 'NON_NULL') {
+        return nonNullable;
+    }
+    return t.tsUnionType([nonNullable, t.tsNullKeyword()]);
+}
+function buildRawResultTsTypeNonNullable(typeRef) {
+    if (typeRef.kind === 'NON_NULL' && typeRef.ofType) {
+        return buildRawResultTsTypeNonNullable(typeRef.ofType);
+    }
+    if (typeRef.kind === 'LIST' && typeRef.ofType) {
+        return t.tsArrayType(buildRawResultTsType(typeRef.ofType));
+    }
+    if (typeRef.kind === 'SCALAR') {
+        return scalarTsTypeToAst(scalarToTsType(typeRef.name ?? 'unknown'));
+    }
+    return t.tsTypeReference(t.identifier(typeRef.name ?? 'unknown'));
+}
 function buildOperationMethod(op, operationType) {
     const hasArgs = op.args.length > 0;
     const varTypeName = `${ucFirst(op.name)}Variables`;
@@ -198,10 +233,9 @@ function buildOperationMethod(op, operationType) {
     }
     else {
         // Scalar/Connection type: use raw TS type directly
-        const rawTsType = typeRefToTsType(op.returnType);
         newExpr.typeParameters = t.tsTypeParameterInstantiation([
             t.tsTypeLiteral([
-                t.tsPropertySignature(t.identifier(op.name), t.tsTypeAnnotation(parseTypeAnnotation(rawTsType))),
+                t.tsPropertySignature(t.identifier(op.name), t.tsTypeAnnotation(buildRawResultTsType(op.returnType))),
             ]),
         ]);
     }