sonamu 0.10.8 → 0.10.10

package/dist/template/implementations/services.template.js

@@ -201,7 +201,7 @@ export const ${infiniteHookName} = ${typeParamsDef}(${paramsDef}${paramsDef ? ",
 					const mutationParamNames = paramsWithoutContext.length > 0 ? paramsWithoutContext.map((p) => `params.${p.name}`).join(", ") : "";
 					functions.push(`
 export const use${hookName}Mutation = ${typeParamsDef}() => useMutation({
-  mutationFn: (params: ${mutationParamType}) => ${methodName}(${mutationParamNames})
+  mutationFn: (params: ${mutationParamType}) => ${modelName}Service.${methodName}(${mutationParamNames})
 });
           `.trim());
 				}
@@ -209,7 +209,7 @@ export const use${hookName}Mutation = ${typeParamsDef}() => useMutation({
 					const hookName = inflection.camelize(api.methodName);
 					const paramsTypeDef = paramsWithoutContext.length > 0 ? paramsDef.split(":").slice(1).join(":").trim() : "";
 					const mutationParamType = paramsWithoutContext.length > 0 ? `{ params: ${paramsTypeDef}, files: File[] }` : `{ files: File[] }`;
-					const mutationFnCall = paramsWithoutContext.length > 0 ? `${methodName}(params.params, params.files)` : `${methodName}(params.files)`;
+					const mutationFnCall = paramsWithoutContext.length > 0 ? `${modelName}Service.${methodName}(params.params, params.files)` : `${modelName}Service.${methodName}(params.files)`;
 					functions.push(`
 export const use${hookName}Mutation = ${typeParamsDef}(
   options?: UseMutationOptions<${returnTypeDef}, Error, ${mutationParamType}> & {
@@ -300,4 +300,4 @@ export const ${names.capital}AsyncIdConfig: AsyncIdConfig<${names.capital}Subset
 //#endregion
 export { Template__services };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"services.template.js","names":[],"sources":["../../../src/template/implementations/services.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { diff, unique } from \"radashi\";\n\nimport {\n  apiParamToTsCode,\n  apiParamTypeToTsType,\n  unwrapPromiseOnce,\n} from \"../../api/code-converters\";\nimport { type ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { type TemplateOptions } from \"../../types/types\";\nimport { ApiParamType } from \"../../types/types\";\nimport { assertDefined } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { BUILT_IN_TYPES, zodTypeToTsTypeDef } from \"../zod-converter\";\n\nexport class Template__services extends Template {\n  constructor() {\n    super(\"services\");\n  }\n\n  getTargetAndPath() {\n    return {\n      target: \":target/src/services\",\n      path: `services.generated.ts`,\n    };\n  }\n\n  render({}: TemplateOptions[\"services\"]) {\n    const { apis } = Sonamu.syncer;\n\n    // 모델별로 그룹화\n    const apisByModel = new Map<string, ExtendedApi[]>();\n    for (const api of apis) {\n      const modelName = api.modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\");\n      if (!apisByModel.has(modelName)) {\n        apisByModel.set(modelName, []);\n      }\n      apisByModel.get(modelName)?.push(api);\n    }\n\n    const importKeys: string[] = [];\n    const namespaces: string[] = [];\n    let typeParamNames: string[] = [];\n    const resolveWebSocketEventTypeDef = (\n      typeRef: ApiParamType.Ref | undefined,\n      schema: Parameters<typeof zodTypeToTsTypeDef>[0],\n    ): string => {\n      if (typeRef) {\n        const candidateImportKeys: string[] = [];\n        const candidateTypeDef = apiParamTypeToTsType(typeRef, candidateImportKeys);\n\n        try {\n          for (const key of unique(candidateImportKeys)) {\n            EntityManager.getModulePath(key);\n          }\n          importKeys.push(...candidateImportKeys);\n          return candidateTypeDef;\n        } catch {\n          // 로컬 const 등 import 가능한 심볼이 아니면 기존 inline 생성으로 후퇴\n        }\n      }\n\n      return zodTypeToTsTypeDef(schema);\n    };\n\n    for (const [modelName, modelApis] of apisByModel) {\n      const functions: string[] = [];\n\n      for (const api of modelApis) {\n        // @stream 데코레이터가 있으면 SSE 스트림 함수 생성\n        if (api.streamOptions) {\n          const paramsWithoutContext = api.parameters.filter(\n            (param) =>\n              !ApiParamType.isContext(param.type) &&\n              !ApiParamType.isRefKnex(param.type) &&\n              !(param.optional && param.name.startsWith(\"_\")),\n          );\n\n          const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n          const methodNameStream = api.options.resourceName\n            ? `use${inflection.camelize(api.options.resourceName)}`\n            : `use${inflection.camelize(api.methodName)}`;\n          const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);\n\n          const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);\n\n          // 파라미터를 객체 형태로 정의 (타입과 실제 값 모두에 사용)\n          const paramsDefAsObject =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(\", \")} }`\n              : \"{}\";\n\n          functions.push(\n            `\nexport function ${methodNameStreamCamelized}(\n  params: ${paramsDefAsObject},\n  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,\n  options: SSEStreamOptions\n) {\n  return useSSEStream<${eventsTypeDef}>(\\`${apiBaseUrl}\\`, params, handlers, options);\n}\n            `.trim(),\n          );\n          continue;\n        }\n\n        if (api.websocketOptions) {\n          // websocket surface는 fetch 함수 대신 typed hook을 생성함\n          const paramsWithoutContext = api.parameters.filter(\n            (param) =>\n              !ApiParamType.isContext(param.type) &&\n              !ApiParamType.isRefKnex(param.type) &&\n              !(param.optional && param.name.startsWith(\"_\")),\n          );\n\n          const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n          const methodNameWebSocket = api.options.resourceName\n            ? `use${inflection.camelize(api.options.resourceName)}`\n            : `use${inflection.camelize(api.methodName)}`;\n          const methodNameWebSocketCamelized = inflection.camelize(methodNameWebSocket, true);\n\n          // outEvents는 수신 타입, inEvents는 send() 입력 타입으로 사용함\n          const outEventsTypeDef = resolveWebSocketEventTypeDef(\n            api.websocketOptions.outEventsTypeRef,\n            api.websocketOptions.outEvents,\n          );\n          const inEventsTypeDef = resolveWebSocketEventTypeDef(\n            api.websocketOptions.inEventsTypeRef,\n            api.websocketOptions.inEvents,\n          );\n\n          // context/refKnex/internal optional 파라미터는 클라이언트 입력에서 제외함\n          const paramsDefAsObject =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(\", \")} }`\n              : \"{}\";\n\n          functions.push(\n            `\nexport function ${methodNameWebSocketCamelized}(\n  params: ${paramsDefAsObject},\n  handlers: EventHandlers<${outEventsTypeDef}>,\n  options: WebSocketChannelOptions = {}\n) {\n  return useWebSocketChannel<${outEventsTypeDef}, ${inEventsTypeDef}>(\\`${apiBaseUrl}\\`, params, handlers, options);\n}\n            `.trim(),\n          );\n          continue;\n        }\n\n        // Context 제외한 파라미터\n        const paramsWithoutContext = api.parameters.filter(\n          (param) =>\n            !ApiParamType.isContext(param.type) &&\n            !ApiParamType.isRefKnex(param.type) &&\n            !(param.optional && param.name.startsWith(\"_\")),\n        );\n\n        // 타입 파라미터 정의\n        const typeParametersAsTsType = api.typeParameters\n          .map((typeParam) => apiParamTypeToTsType(typeParam, importKeys))\n          .join(\", \");\n        const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : \"\";\n        typeParamNames = typeParamNames.concat(api.typeParameters.map((tp) => tp.id));\n\n        // 파라미터 정의\n        const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);\n        const paramNames = paramsWithoutContext.map((p) => p.name).join(\", \");\n\n        // 리턴 타입 정의\n        const returnTypeDef = apiParamTypeToTsType(\n          assertDefined(unwrapPromiseOnce(api.returnType)),\n          importKeys,\n        );\n\n        // 기본 URL\n        const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n        const clients = api.options.clients || [];\n\n        // 1. axios 함수 생성\n        // resourceName이 있으면 get + resourceName 형태로 함수명 생성\n        const methodName = api.options.resourceName\n          ? `get${inflection.camelize(api.options.resourceName)}`\n          : api.methodName;\n\n        // axios-multipart 처리 (파일 업로드)\n        if (clients.includes(\"axios-multipart\")) {\n          const formDataAppend = `files.forEach(f => { formData.append(\"files\", f); });`;\n\n          const otherParamsAppend = paramsWithoutContext\n            .map((param) => {\n              // primitive 타입인지 체크\n              const isPrimitive =\n                typeof param.type === \"string\" &&\n                [\"string\", \"number\", \"boolean\"].includes(param.type);\n\n              if (isPrimitive) {\n                // primitive: 직접 formData.append\n                return `formData.append('${param.name}', String(${param.name}));`;\n              } else {\n                // object: toFormData 사용\n                return `toFormData(${param.name}, formData, '${param.name}');`;\n              }\n            })\n            .join(\"\\n    \");\n\n          const paramsDefComma = paramsDef !== \"\" ? \", \" : \"\";\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(\n  ${paramsDef}${paramsDefComma}\n  files: File[],\n  onUploadProgress?: (pe: AxiosProgressEvent) => void\n): Promise<${returnTypeDef}> {\n  const formData = new FormData();\n  ${formDataAppend}\n  ${otherParamsAppend}\n  return fetch({\n    method: 'POST',\n    url: \\`${apiBaseUrl}\\`,\n    onUploadProgress,\n    data: formData,\n    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n  });\n}\n          `.trim(),\n          );\n        } else if (api.options.httpMethod === \"GET\") {\n          const hasParams = paramsWithoutContext.length > 0;\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n  return fetch({\n    method: \"GET\",\n    url: \\`${apiBaseUrl}${hasParams ? `?\\${qs.stringify({ ${paramNames} })}` : \"\"}\\`,\n    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n  });\n}\n          `.trim(),\n          );\n        } else {\n          const hasParams = paramsWithoutContext.length > 0;\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n  return fetch({\n    method: \"${api.options.httpMethod}\",\n    url: \\`${apiBaseUrl}\\`,\n    ${hasParams ? `data: { ${paramNames} },` : \"\"}\n    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n  });\n}\n          `.trim(),\n          );\n        }\n\n        // 2. queryOptions + useQuery (tanstack-query)\n        if (clients.includes(\"tanstack-query\")) {\n          const hookName = api.options.resourceName\n            ? inflection.camelize(api.options.resourceName, true)\n            : inflection.camelize(api.methodName, true);\n\n          // queryOptions\n          functions.push(\n            `\nexport const ${methodName}QueryOptions = ${typeParamsDef}(${paramsDef}) => queryOptions({\n  queryKey: ['${modelName}', '${methodName}'${paramNames ? `, ${paramNames}` : \"\"}],\n  queryFn: () => ${methodName}(${paramNames})\n});\n          `.trim(),\n          );\n\n          // useQuery hook (useRefreshable로 래핑해 refresh/isRefreshing을 기본 제공)\n          functions.push(\n            `\nexport const use${inflection.camelize(hookName)} = ${typeParamsDef}(${paramsDef}${\n              paramsDef ? \", \" : \"\"\n            }options?: { enabled?: boolean }) =>\n  useRefreshable(useQuery({\n    ...${methodName}QueryOptions(${paramNames}),\n    ...options\n  }));\n          `.trim(),\n          );\n\n          // infiniteQueryOptions + useInfiniteQuery (AsyncIdConfig.useListInfinite 대상 조건)\n          // 조건: resourceName이 복수형이고 methodName === \"findMany\"\n          const resourceName = api.options.resourceName;\n          const isInfiniteTarget =\n            !!resourceName &&\n            inflection.pluralize(resourceName) === resourceName &&\n            api.methodName === \"findMany\";\n\n          if (isInfiniteTarget) {\n            const infiniteMethodName = `${methodName}Infinite`;\n            const infiniteHookName = `use${inflection.camelize(hookName)}Infinite`;\n\n            functions.push(\n              `\nexport const ${infiniteMethodName}QueryOptions = ${typeParamsDef}(${paramsDef}) => infiniteQueryOptions({\n  queryKey: ['${modelName}', '${methodName}', 'infinite'${paramNames ? `, ${paramNames}` : \"\"}],\n  queryFn: ({ pageParam }) => ${methodName}(${\n    paramNames ? paramNames.replace(/\\brawParams\\b/, \"{ ...rawParams, page: pageParam }\") : \"\"\n  }),\n  initialPageParam: 1 as number,\n  getNextPageParam: (lastPage, allPages) => {\n    const total = (lastPage as { total?: number })?.total ?? 0;\n    const loaded = allPages.reduce(\n      (sum, p) => sum + ((p as { rows?: unknown[] })?.rows?.length ?? 0),\n      0,\n    );\n    return loaded < total ? allPages.length + 1 : undefined;\n  },\n  select: dedupeAndFlatten,\n});\n          `.trim(),\n            );\n\n            functions.push(\n              `\nexport const ${infiniteHookName} = ${typeParamsDef}(${paramsDef}${\n                paramsDef ? \", \" : \"\"\n              }options?: { enabled?: boolean }) =>\n  useRefreshable(useInfiniteQuery({\n    ...${infiniteMethodName}QueryOptions(${paramNames}),\n    ...options\n  }));\n          `.trim(),\n            );\n          }\n        }\n\n        // 3. useMutation (tanstack-mutation)\n        if (clients.includes(\"tanstack-mutation\")) {\n          const hookName = inflection.camelize(api.methodName);\n          const mutationParamType =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext\n                  .map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, [])}`)\n                  .join(\", \")} }`\n              : \"void\";\n          const mutationParamNames =\n            paramsWithoutContext.length > 0\n              ? paramsWithoutContext.map((p) => `params.${p.name}`).join(\", \")\n              : \"\";\n\n          functions.push(\n            `\nexport const use${hookName}Mutation = ${typeParamsDef}() => useMutation({\n  mutationFn: (params: ${mutationParamType}) => ${methodName}(${mutationParamNames})\n});\n          `.trim(),\n          );\n        }\n\n        // 4. useMutation with multipart (tanstack-mutation-multipart)\n        if (clients.includes(\"tanstack-mutation-multipart\")) {\n          const hookName = inflection.camelize(api.methodName);\n\n          // 파라미터 타입 정의: paramsDef에서 타입만 추출\n          // paramsDef 예: \"params: { category: string }\" → \"{ category: string }\"\n          const paramsTypeDef =\n            paramsWithoutContext.length > 0\n              ? paramsDef.split(\":\").slice(1).join(\":\").trim() // \"params: { category: string }\" → \"{ category: string }\"\n              : \"\";\n\n          const mutationParamType =\n            paramsWithoutContext.length > 0\n              ? `{ params: ${paramsTypeDef}, files: File[] }`\n              : `{ files: File[] }`;\n\n          // mutationFn 호출 파라미터\n          const mutationFnCall =\n            paramsWithoutContext.length > 0\n              ? `${methodName}(params.params, params.files)`\n              : `${methodName}(params.files)`;\n\n          functions.push(\n            `\nexport const use${hookName}Mutation = ${typeParamsDef}(\n  options?: UseMutationOptions<${returnTypeDef}, Error, ${mutationParamType}> & {\n    onUploadProgress?: (e: AxiosProgressEvent) => void;\n  }\n) => useMutation({\n  mutationFn: (params: ${mutationParamType}) => ${mutationFnCall},\n  retry: false,\n  ...options,\n});\n          `.trim(),\n          );\n        }\n      }\n\n      namespaces.push(\n        `\nexport namespace ${modelName}Service {\n${functions.join(\"\\n\\n\")}\n}\n      `.trim(),\n      );\n    }\n\n    // AsyncIdConfig 생성 (Entity별로)\n    const entityIds = EntityManager.getAllIds();\n    const asyncIdConfigs: string[] = [];\n\n    for (const entityId of entityIds) {\n      const names = EntityManager.getNamesFromId(entityId);\n\n      // AsyncIdConfig용 리스트 조회 API 찾기\n      const listApi = apisByModel.get(names.capital)?.find((api) => {\n        // resourceName이 없거나 tanstack-query를 사용하지 않는 API는 제외\n        if (!api.options.resourceName || !api.options.clients?.includes(\"tanstack-query\")) {\n          return false;\n        }\n        // resourceName이 복수형이고 메서드명이 findMany인 API\n        const resourceName = api.options.resourceName;\n        return inflection.pluralize(resourceName) === resourceName && api.methodName === \"findMany\";\n      });\n\n      if (listApi) {\n        // resourceName에서 hook 이름 생성 (기존 로직과 동일)\n        const hookName = inflection.camelize(assertDefined(listApi.options.resourceName), true);\n        const useHookName = `use${inflection.camelize(hookName)}`;\n        const useHookInfiniteName = `${useHookName}Infinite`;\n\n        // ListParams 타입명 구성\n        const listParamsType = `${names.capital}ListParams`;\n\n        asyncIdConfigs.push(\n          `\n// AsyncIdConfig: ${names.capital}\nexport const ${names.capital}AsyncIdConfig: AsyncIdConfig<${names.capital}SubsetKey, ${names.capital}SubsetMapping, ${listParamsType}> = {\n  placeholderKey: \"entity.${names.capital}\",\n  useList: ${names.capital}Service.${useHookName},\n  useListInfinite: ${names.capital}Service.${useHookInfiniteName},\n};\n          `.trim(),\n        );\n      }\n    }\n\n    // BUILT_IN_TYPES에서 사용되는 타입들을 확인하여 동적으로 import 구성\n    const builtInTypeImports = Object.keys(BUILT_IN_TYPES)\n      .filter((typeKey) => importKeys.includes(typeKey))\n      .map((typeKey) => `type ${typeKey}`);\n\n    // sonamu.shared에서 import할 항목들을 동적으로 구성\n    // body 문자열을 기준으로 infinite 훅 생성 여부 판단 (findMany 복수형 분기에서만 참조됨)\n    const bodyForImportCheck = namespaces.join(\"\\n\\n\");\n    const needsDedupeAndFlatten = bodyForImportCheck.includes(\"dedupeAndFlatten\");\n    const needsUseRefreshable = bodyForImportCheck.includes(\"useRefreshable\");\n\n    const sonamuSharedImports = [\n      \"type ListResult\",\n      \"type FilterQuery\",\n      ...builtInTypeImports,\n      \"fetch\",\n      \"type EventHandlers\",\n      \"type SSEStreamOptions\",\n      \"type WebSocketChannelOptions\",\n      \"useSSEStream\",\n      \"useWebSocketChannel\",\n      \"toFormData\",\n      ...(needsDedupeAndFlatten ? [\"dedupeAndFlatten\"] : []),\n      ...(needsUseRefreshable ? [\"useRefreshable\"] : []),\n    ].join(\", \");\n\n    // body 구성: namespaces + asyncIdConfigs\n    const bodyParts = [...namespaces, ...asyncIdConfigs];\n\n    return {\n      ...this.getTargetAndPath(),\n      body: bodyParts.join(\"\\n\\n\"),\n      importKeys: diff(unique(importKeys), [\n        ...typeParamNames,\n        \"ListResult\",\n        ...Object.keys(BUILT_IN_TYPES),\n      ]),\n      customHeaders: [\n        \"/**\",\n        \" * @generated\",\n        \" * 직접 수정하지 마세요.\",\n        \" */\",\n        \"\",\n        \"/* oxlint-disable */\",\n        \"\",\n        `import { queryOptions, useQuery, useInfiniteQuery, infiniteQueryOptions, useMutation, type UseMutationOptions } from '@tanstack/react-query';`,\n        `import { type AxiosProgressEvent } from 'axios';`,\n        `import qs from 'qs';`,\n        `import { ${sonamuSharedImports} } from './sonamu.shared';`,\n        `import { type AsyncIdConfig } from '@sonamu-kit/react-components/components';`,\n      ],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;qBAOkC;YAEO;oBACkB;WAEX;WACC;cACX;mBAC+B;AAErE,IAAa,qBAAb,cAAwC,SAAS;CAC/C,cAAc;EACZ,MAAM,UAAU;CAClB;CAEA,mBAAmB;EACjB,OAAO;GACL,QAAQ;GACR,MAAM;EACR;CACF;CAEA,OAAO,IAAiC;EACtC,MAAM,EAAE,SAAS,OAAO;EAGxB,MAAM,8BAAc,IAAI,IAA2B;EACnD,KAAK,MAAM,OAAO,MAAM;GACtB,MAAM,YAAY,IAAI,UAAU,QAAQ,UAAU,EAAE,CAAC,CAAC,QAAQ,UAAU,EAAE;GAC1E,IAAI,CAAC,YAAY,IAAI,SAAS,GAC5B,YAAY,IAAI,WAAW,CAAC,CAAC;GAE/B,YAAY,IAAI,SAAS,CAAC,EAAE,KAAK,GAAG;EACtC;EAEA,MAAM,aAAuB,CAAC;EAC9B,MAAM,aAAuB,CAAC;EAC9B,IAAI,iBAA2B,CAAC;EAChC,MAAM,gCACJ,SACA,WACW;GACX,IAAI,SAAS;IACX,MAAM,sBAAgC,CAAC;IACvC,MAAM,mBAAmB,qBAAqB,SAAS,mBAAmB;IAE1E,IAAI;KACF,KAAK,MAAM,OAAO,OAAO,mBAAmB,GAC1C,cAAc,cAAc,GAAG;KAEjC,WAAW,KAAK,GAAG,mBAAmB;KACtC,OAAO;IACT,QAAQ,CAER;GACF;GAEA,OAAO,mBAAmB,MAAM;EAClC;EAEA,KAAK,MAAM,CAAC,WAAW,cAAc,aAAa;GAChD,MAAM,YAAsB,CAAC;GAE7B,KAAK,MAAM,OAAO,WAAW;IAE3B,IAAI,IAAI,eAAe;KACrB,MAAM,uBAAuB,IAAI,WAAW,QACzC,UACC,CAAC,aAAa,UAAU,MAAM,IAAI,KAClC,CAAC,aAAa,UAAU,MAAM,IAAI,KAClC,EAAE,MAAM,YAAY,MAAM,KAAK,WAAW,GAAG,EACjD;KAEA,MAAM,aAAa,GAAG,OAAO,OAAO,IAAI,MAAM,SAAS,IAAI;KAE3D,MAAM,mBAAmB,IAAI,QAAQ,eACjC,MAAM,WAAW,SAAS,IAAI,QAAQ,YAAY,MAClD,MAAM,WAAW,SAAS,IAAI,UAAU;KAC5C,MAAM,4BAA4B,WAAW,SAAS,kBAAkB,IAAI;KAE5E,MAAM,gBAAgB,mBAAmB,IAAI,cAAc,MAAM;KAGjE,MAAM,oBACJ,qBAAqB,SAAS,IAC1B,KAAK,qBAAqB,KAAK,MAAM,GAAG,EAAE,KAAK,IAAI,qBAAqB,EAAE,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,MAC1G;KAEN,UAAU,KACR;kBACM,0BAA0B;YAChC,kBAAkB;4BACF,cAAc;;;wBAGlB,cAAc,MAAM,WAAW;;cAEzC,KAAK,CACT;KACA;IACF;IAEA,IAAI,IAAI,kBAAkB;KAExB,MAAM,uBAAuB,IAAI,WAAW,QACzC,UACC,CAAC,aAAa,UAAU,MAAM,IAAI,KAClC,CAAC,aAAa,UAAU,MAAM,IAAI,KAClC,EAAE,MAAM,YAAY,MAAM,KAAK,WAAW,GAAG,EACjD;KAEA,MAAM,aAAa,GAAG,OAAO,OAAO,IAAI,MAAM,SAAS,IAAI;KAE3D,MAAM,sBAAsB,IAAI,QAAQ,eACpC,MAAM,WAAW,SAAS,IAAI,QAAQ,YAAY,MAClD,MAAM,WAAW,SAAS,IAAI,UAAU;KAC5C,MAAM,+BAA+B,WAAW,SAAS,qBAAqB,IAAI;KAGlF,MAAM,mBAAmB,6BACvB,IAAI,iBAAiB,kBACrB,IAAI,iBAAiB,SACvB;KACA,MAAM,kBAAkB,6BACtB,IAAI,iBAAiB,iBACrB,IAAI,iBAAiB,QACvB;KAGA,MAAM,oBACJ,qBAAqB,SAAS,IAC1B,KAAK,qBAAqB,KAAK,MAAM,GAAG,EAAE,KAAK,IAAI,qBAAqB,EAAE,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,MAC1G;KAEN,UAAU,KACR;kBACM,6BAA6B;YACnC,kBAAkB;4BACF,iBAAiB;;;+BAGd,iBAAiB,IAAI,gBAAgB,MAAM,WAAW;;cAEvE,KAAK,CACT;KACA;IACF;IAGA,MAAM,uBAAuB,IAAI,WAAW,QACzC,UACC,CAAC,aAAa,UAAU,MAAM,IAAI,KAClC,CAAC,aAAa,UAAU,MAAM,IAAI,KAClC,EAAE,MAAM,YAAY,MAAM,KAAK,WAAW,GAAG,EACjD;IAGA,MAAM,yBAAyB,IAAI,eAChC,KAAK,cAAc,qBAAqB,WAAW,UAAU,CAAC,CAAC,CAC/D,KAAK,IAAI;IACZ,MAAM,gBAAgB,yBAAyB,IAAI,uBAAuB,KAAK;IAC/E,iBAAiB,eAAe,OAAO,IAAI,eAAe,KAAK,OAAO,GAAG,EAAE,CAAC;IAG5E,MAAM,YAAY,iBAAiB,sBAAsB,UAAU;IACnE,MAAM,aAAa,qBAAqB,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI;IAGpE,MAAM,gBAAgB,qBACpB,cAAc,kBAAkB,IAAI,UAAU,CAAC,GAC/C,UACF;IAGA,MAAM,aAAa,GAAG,OAAO,OAAO,IAAI,MAAM,SAAS,IAAI;IAE3D,MAAM,UAAU,IAAI,QAAQ,WAAW,CAAC;IAIxC,MAAM,aAAa,IAAI,QAAQ,eAC3B,MAAM,WAAW,SAAS,IAAI,QAAQ,YAAY,MAClD,IAAI;IAGR,IAAI,QAAQ,SAAS,iBAAiB,GAAG;KACvC,MAAM,iBAAiB;KAEvB,MAAM,oBAAoB,qBACvB,KAAK,UAAU;MAMd,IAHE,OAAO,MAAM,SAAS,YACtB;OAAC;OAAU;OAAU;MAAS,CAAC,CAAC,SAAS,MAAM,IAAI,GAInD,OAAO,oBAAoB,MAAM,KAAK,YAAY,MAAM,KAAK;WAG7D,OAAO,cAAc,MAAM,KAAK,eAAe,MAAM,KAAK;KAE9D,CAAC,CAAC,CACD,KAAK,QAAQ;KAEhB,MAAM,iBAAiB,cAAc,KAAK,OAAO;KACjD,UAAU,KACR;wBACY,aAAa,cAAc;IAC/C,YAAY,eAAe;;;aAGlB,cAAc;;IAEvB,eAAe;IACf,kBAAkB;;;aAGT,WAAW;;;MAGlB,IAAI,QAAQ,UAAU,+BAA+B,IAAI,QAAQ,QAAQ,MAAM,GAAG;;;YAG5E,KAAK,CACP;IACF,OAAO,IAAI,IAAI,QAAQ,eAAe,OAAO;KAC3C,MAAM,YAAY,qBAAqB,SAAS;KAChD,UAAU,KACR;wBACY,aAAa,cAAc,GAAG,UAAU,aAAa,cAAc;;;aAG9E,aAAa,YAAY,sBAAsB,WAAW,QAAQ,GAAG;MAC5E,IAAI,QAAQ,UAAU,+BAA+B,IAAI,QAAQ,QAAQ,MAAM,GAAG;;;YAG5E,KAAK,CACP;IACF,OAAO;KACL,MAAM,YAAY,qBAAqB,SAAS;KAChD,UAAU,KACR;wBACY,aAAa,cAAc,GAAG,UAAU,aAAa,cAAc;;eAE5E,IAAI,QAAQ,WAAW;aACzB,WAAW;MAClB,YAAY,WAAW,WAAW,OAAO,GAAG;MAC5C,IAAI,QAAQ,UAAU,+BAA+B,IAAI,QAAQ,QAAQ,MAAM,GAAG;;;YAG5E,KAAK,CACP;IACF;IAGA,IAAI,QAAQ,SAAS,gBAAgB,GAAG;KACtC,MAAM,WAAW,IAAI,QAAQ,eACzB,WAAW,SAAS,IAAI,QAAQ,cAAc,IAAI,IAClD,WAAW,SAAS,IAAI,YAAY,IAAI;KAG5C,UAAU,KACR;eACG,WAAW,iBAAiB,cAAc,GAAG,UAAU;gBACtD,UAAU,MAAM,WAAW,GAAG,aAAa,KAAK,eAAe,GAAG;mBAC/D,WAAW,GAAG,WAAW;;YAEhC,KAAK,CACP;KAGA,UAAU,KACR;kBACM,WAAW,SAAS,QAAQ,EAAE,KAAK,cAAc,GAAG,YACxD,YAAY,OAAO,GACpB;;SAEJ,WAAW,eAAe,WAAW;;;YAGlC,KAAK,CACP;KAIA,MAAM,eAAe,IAAI,QAAQ;KAMjC,IAJE,CAAC,CAAC,gBACF,WAAW,UAAU,YAAY,MAAM,gBACvC,IAAI,eAAe,YAEC;MACpB,MAAM,qBAAqB,GAAG,WAAW;MACzC,MAAM,mBAAmB,MAAM,WAAW,SAAS,QAAQ,EAAE;MAE7D,UAAU,KACR;eACC,mBAAmB,iBAAiB,cAAc,GAAG,UAAU;gBAC9D,UAAU,MAAM,WAAW,eAAe,aAAa,KAAK,eAAe,GAAG;gCAC9D,WAAW,GACvC,aAAa,WAAW,QAAQ,iBAAiB,mCAAmC,IAAI,GACzF;;;;;;;;;;;;YAYS,KAAK,CACL;MAEA,UAAU,KACR;eACC,iBAAiB,KAAK,cAAc,GAAG,YACtC,YAAY,OAAO,GACpB;;SAEN,mBAAmB,eAAe,WAAW;;;YAG1C,KAAK,CACL;KACF;IACF;IAGA,IAAI,QAAQ,SAAS,mBAAmB,GAAG;KACzC,MAAM,WAAW,WAAW,SAAS,IAAI,UAAU;KACnD,MAAM,oBACJ,qBAAqB,SAAS,IAC1B,KAAK,qBACF,KAAK,MAAM,GAAG,EAAE,KAAK,IAAI,qBAAqB,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAC5D,KAAK,IAAI,EAAE,MACd;KACN,MAAM,qBACJ,qBAAqB,SAAS,IAC1B,qBAAqB,KAAK,MAAM,UAAU,EAAE,MAAM,CAAC,CAAC,KAAK,IAAI,IAC7D;KAEN,UAAU,KACR;kBACM,SAAS,aAAa,cAAc;yBAC7B,kBAAkB,OAAO,WAAW,GAAG,mBAAmB;;YAEvE,KAAK,CACP;IACF;IAGA,IAAI,QAAQ,SAAS,6BAA6B,GAAG;KACnD,MAAM,WAAW,WAAW,SAAS,IAAI,UAAU;KAInD,MAAM,gBACJ,qBAAqB,SAAS,IAC1B,UAAU,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,IAC7C;KAEN,MAAM,oBACJ,qBAAqB,SAAS,IAC1B,aAAa,cAAc,qBAC3B;KAGN,MAAM,iBACJ,qBAAqB,SAAS,IAC1B,GAAG,WAAW,iCACd,GAAG,WAAW;KAEpB,UAAU,KACR;kBACM,SAAS,aAAa,cAAc;iCACrB,cAAc,WAAW,kBAAkB;;;;yBAInD,kBAAkB,OAAO,eAAe;;;;YAIrD,KAAK,CACP;IACF;GACF;GAEA,WAAW,KACT;mBACW,UAAU;EAC3B,UAAU,KAAK,MAAM,EAAE;;QAEjB,KAAK,CACP;EACF;EAGA,MAAM,YAAY,cAAc,UAAU;EAC1C,MAAM,iBAA2B,CAAC;EAElC,KAAK,MAAM,YAAY,WAAW;GAChC,MAAM,QAAQ,cAAc,eAAe,QAAQ;GAGnD,MAAM,UAAU,YAAY,IAAI,MAAM,OAAO,CAAC,EAAE,MAAM,QAAQ;IAE5D,IAAI,CAAC,IAAI,QAAQ,gBAAgB,CAAC,IAAI,QAAQ,SAAS,SAAS,gBAAgB,GAC9E,OAAO;IAGT,MAAM,eAAe,IAAI,QAAQ;IACjC,OAAO,WAAW,UAAU,YAAY,MAAM,gBAAgB,IAAI,eAAe;GACnF,CAAC;GAED,IAAI,SAAS;IAEX,MAAM,WAAW,WAAW,SAAS,cAAc,QAAQ,QAAQ,YAAY,GAAG,IAAI;IACtF,MAAM,cAAc,MAAM,WAAW,SAAS,QAAQ;IACtD,MAAM,sBAAsB,GAAG,YAAY;IAG3C,MAAM,iBAAiB,GAAG,MAAM,QAAQ;IAExC,eAAe,KACb;oBACU,MAAM,QAAQ;eACnB,MAAM,QAAQ,+BAA+B,MAAM,QAAQ,aAAa,MAAM,QAAQ,iBAAiB,eAAe;4BACzG,MAAM,QAAQ;aAC7B,MAAM,QAAQ,UAAU,YAAY;qBAC5B,MAAM,QAAQ,UAAU,oBAAoB;;YAErD,KAAK,CACT;GACF;EACF;EAGA,MAAM,qBAAqB,OAAO,KAAK,cAAc,CAAC,CACnD,QAAQ,YAAY,WAAW,SAAS,OAAO,CAAC,CAAC,CACjD,KAAK,YAAY,QAAQ,SAAS;EAIrC,MAAM,qBAAqB,WAAW,KAAK,MAAM;EACjD,MAAM,wBAAwB,mBAAmB,SAAS,kBAAkB;EAC5E,MAAM,sBAAsB,mBAAmB,SAAS,gBAAgB;EAExE,MAAM,sBAAsB;GAC1B;GACA;GACA,GAAG;GACH;GACA;GACA;GACA;GACA;GACA;GACA;GACA,GAAI,wBAAwB,CAAC,kBAAkB,IAAI,CAAC;GACpD,GAAI,sBAAsB,CAAC,gBAAgB,IAAI,CAAC;EAClD,CAAC,CAAC,KAAK,IAAI;EAGX,MAAM,YAAY,CAAC,GAAG,YAAY,GAAG,cAAc;EAEnD,OAAO;GACL,GAAG,KAAK,iBAAiB;GACzB,MAAM,UAAU,KAAK,MAAM;GAC3B,YAAY,KAAK,OAAO,UAAU,GAAG;IACnC,GAAG;IACH;IACA,GAAG,OAAO,KAAK,cAAc;GAC/B,CAAC;GACD,eAAe;IACb;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,YAAY,oBAAoB;IAChC;GACF;EACF;CACF;AACF"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"services.template.js","names":[],"sources":["../../../src/template/implementations/services.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { diff, unique } from \"radashi\";\n\nimport {\n  apiParamToTsCode,\n  apiParamTypeToTsType,\n  unwrapPromiseOnce,\n} from \"../../api/code-converters\";\nimport { type ExtendedApi } from \"../../api/decorators\";\nimport { Sonamu } from \"../../api/sonamu\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { type TemplateOptions } from \"../../types/types\";\nimport { ApiParamType } from \"../../types/types\";\nimport { assertDefined } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { BUILT_IN_TYPES, zodTypeToTsTypeDef } from \"../zod-converter\";\n\nexport class Template__services extends Template {\n  constructor() {\n    super(\"services\");\n  }\n\n  getTargetAndPath() {\n    return {\n      target: \":target/src/services\",\n      path: `services.generated.ts`,\n    };\n  }\n\n  render({}: TemplateOptions[\"services\"]) {\n    const { apis } = Sonamu.syncer;\n\n    // 모델별로 그룹화\n    const apisByModel = new Map<string, ExtendedApi[]>();\n    for (const api of apis) {\n      const modelName = api.modelName.replace(/Model$/, \"\").replace(/Frame$/, \"\");\n      if (!apisByModel.has(modelName)) {\n        apisByModel.set(modelName, []);\n      }\n      apisByModel.get(modelName)?.push(api);\n    }\n\n    const importKeys: string[] = [];\n    const namespaces: string[] = [];\n    let typeParamNames: string[] = [];\n    const resolveWebSocketEventTypeDef = (\n      typeRef: ApiParamType.Ref | undefined,\n      schema: Parameters<typeof zodTypeToTsTypeDef>[0],\n    ): string => {\n      if (typeRef) {\n        const candidateImportKeys: string[] = [];\n        const candidateTypeDef = apiParamTypeToTsType(typeRef, candidateImportKeys);\n\n        try {\n          for (const key of unique(candidateImportKeys)) {\n            EntityManager.getModulePath(key);\n          }\n          importKeys.push(...candidateImportKeys);\n          return candidateTypeDef;\n        } catch {\n          // 로컬 const 등 import 가능한 심볼이 아니면 기존 inline 생성으로 후퇴\n        }\n      }\n\n      return zodTypeToTsTypeDef(schema);\n    };\n\n    for (const [modelName, modelApis] of apisByModel) {\n      const functions: string[] = [];\n\n      for (const api of modelApis) {\n        // @stream 데코레이터가 있으면 SSE 스트림 함수 생성\n        if (api.streamOptions) {\n          const paramsWithoutContext = api.parameters.filter(\n            (param) =>\n              !ApiParamType.isContext(param.type) &&\n              !ApiParamType.isRefKnex(param.type) &&\n              !(param.optional && param.name.startsWith(\"_\")),\n          );\n\n          const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n          const methodNameStream = api.options.resourceName\n            ? `use${inflection.camelize(api.options.resourceName)}`\n            : `use${inflection.camelize(api.methodName)}`;\n          const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);\n\n          const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);\n\n          // 파라미터를 객체 형태로 정의 (타입과 실제 값 모두에 사용)\n          const paramsDefAsObject =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(\", \")} }`\n              : \"{}\";\n\n          functions.push(\n            `\nexport function ${methodNameStreamCamelized}(\n  params: ${paramsDefAsObject},\n  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,\n  options: SSEStreamOptions\n) {\n  return useSSEStream<${eventsTypeDef}>(\\`${apiBaseUrl}\\`, params, handlers, options);\n}\n            `.trim(),\n          );\n          continue;\n        }\n\n        if (api.websocketOptions) {\n          // websocket surface는 fetch 함수 대신 typed hook을 생성함\n          const paramsWithoutContext = api.parameters.filter(\n            (param) =>\n              !ApiParamType.isContext(param.type) &&\n              !ApiParamType.isRefKnex(param.type) &&\n              !(param.optional && param.name.startsWith(\"_\")),\n          );\n\n          const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n          const methodNameWebSocket = api.options.resourceName\n            ? `use${inflection.camelize(api.options.resourceName)}`\n            : `use${inflection.camelize(api.methodName)}`;\n          const methodNameWebSocketCamelized = inflection.camelize(methodNameWebSocket, true);\n\n          // outEvents는 수신 타입, inEvents는 send() 입력 타입으로 사용함\n          const outEventsTypeDef = resolveWebSocketEventTypeDef(\n            api.websocketOptions.outEventsTypeRef,\n            api.websocketOptions.outEvents,\n          );\n          const inEventsTypeDef = resolveWebSocketEventTypeDef(\n            api.websocketOptions.inEventsTypeRef,\n            api.websocketOptions.inEvents,\n          );\n\n          // context/refKnex/internal optional 파라미터는 클라이언트 입력에서 제외함\n          const paramsDefAsObject =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(\", \")} }`\n              : \"{}\";\n\n          functions.push(\n            `\nexport function ${methodNameWebSocketCamelized}(\n  params: ${paramsDefAsObject},\n  handlers: EventHandlers<${outEventsTypeDef}>,\n  options: WebSocketChannelOptions = {}\n) {\n  return useWebSocketChannel<${outEventsTypeDef}, ${inEventsTypeDef}>(\\`${apiBaseUrl}\\`, params, handlers, options);\n}\n            `.trim(),\n          );\n          continue;\n        }\n\n        // Context 제외한 파라미터\n        const paramsWithoutContext = api.parameters.filter(\n          (param) =>\n            !ApiParamType.isContext(param.type) &&\n            !ApiParamType.isRefKnex(param.type) &&\n            !(param.optional && param.name.startsWith(\"_\")),\n        );\n\n        // 타입 파라미터 정의\n        const typeParametersAsTsType = api.typeParameters\n          .map((typeParam) => apiParamTypeToTsType(typeParam, importKeys))\n          .join(\", \");\n        const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : \"\";\n        typeParamNames = typeParamNames.concat(api.typeParameters.map((tp) => tp.id));\n\n        // 파라미터 정의\n        const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);\n        const paramNames = paramsWithoutContext.map((p) => p.name).join(\", \");\n\n        // 리턴 타입 정의\n        const returnTypeDef = apiParamTypeToTsType(\n          assertDefined(unwrapPromiseOnce(api.returnType)),\n          importKeys,\n        );\n\n        // 기본 URL\n        const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;\n\n        const clients = api.options.clients || [];\n\n        // 1. axios 함수 생성\n        // resourceName이 있으면 get + resourceName 형태로 함수명 생성\n        const methodName = api.options.resourceName\n          ? `get${inflection.camelize(api.options.resourceName)}`\n          : api.methodName;\n\n        // axios-multipart 처리 (파일 업로드)\n        if (clients.includes(\"axios-multipart\")) {\n          const formDataAppend = `files.forEach(f => { formData.append(\"files\", f); });`;\n\n          const otherParamsAppend = paramsWithoutContext\n            .map((param) => {\n              // primitive 타입인지 체크\n              const isPrimitive =\n                typeof param.type === \"string\" &&\n                [\"string\", \"number\", \"boolean\"].includes(param.type);\n\n              if (isPrimitive) {\n                // primitive: 직접 formData.append\n                return `formData.append('${param.name}', String(${param.name}));`;\n              } else {\n                // object: toFormData 사용\n                return `toFormData(${param.name}, formData, '${param.name}');`;\n              }\n            })\n            .join(\"\\n    \");\n\n          const paramsDefComma = paramsDef !== \"\" ? \", \" : \"\";\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(\n  ${paramsDef}${paramsDefComma}\n  files: File[],\n  onUploadProgress?: (pe: AxiosProgressEvent) => void\n): Promise<${returnTypeDef}> {\n  const formData = new FormData();\n  ${formDataAppend}\n  ${otherParamsAppend}\n  return fetch({\n    method: 'POST',\n    url: \\`${apiBaseUrl}\\`,\n    onUploadProgress,\n    data: formData,\n    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n  });\n}\n          `.trim(),\n          );\n        } else if (api.options.httpMethod === \"GET\") {\n          const hasParams = paramsWithoutContext.length > 0;\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n  return fetch({\n    method: \"GET\",\n    url: \\`${apiBaseUrl}${hasParams ? `?\\${qs.stringify({ ${paramNames} })}` : \"\"}\\`,\n    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n  });\n}\n          `.trim(),\n          );\n        } else {\n          const hasParams = paramsWithoutContext.length > 0;\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {\n  return fetch({\n    method: \"${api.options.httpMethod}\",\n    url: \\`${apiBaseUrl}\\`,\n    ${hasParams ? `data: { ${paramNames} },` : \"\"}\n    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : \"\"}\n  });\n}\n          `.trim(),\n          );\n        }\n\n        // 2. queryOptions + useQuery (tanstack-query)\n        if (clients.includes(\"tanstack-query\")) {\n          const hookName = api.options.resourceName\n            ? inflection.camelize(api.options.resourceName, true)\n            : inflection.camelize(api.methodName, true);\n\n          // queryOptions\n          functions.push(\n            `\nexport const ${methodName}QueryOptions = ${typeParamsDef}(${paramsDef}) => queryOptions({\n  queryKey: ['${modelName}', '${methodName}'${paramNames ? `, ${paramNames}` : \"\"}],\n  queryFn: () => ${methodName}(${paramNames})\n});\n          `.trim(),\n          );\n\n          // useQuery hook (useRefreshable로 래핑해 refresh/isRefreshing을 기본 제공)\n          functions.push(\n            `\nexport const use${inflection.camelize(hookName)} = ${typeParamsDef}(${paramsDef}${\n              paramsDef ? \", \" : \"\"\n            }options?: { enabled?: boolean }) =>\n  useRefreshable(useQuery({\n    ...${methodName}QueryOptions(${paramNames}),\n    ...options\n  }));\n          `.trim(),\n          );\n\n          // infiniteQueryOptions + useInfiniteQuery (AsyncIdConfig.useListInfinite 대상 조건)\n          // 조건: resourceName이 복수형이고 methodName === \"findMany\"\n          const resourceName = api.options.resourceName;\n          const isInfiniteTarget =\n            !!resourceName &&\n            inflection.pluralize(resourceName) === resourceName &&\n            api.methodName === \"findMany\";\n\n          if (isInfiniteTarget) {\n            const infiniteMethodName = `${methodName}Infinite`;\n            const infiniteHookName = `use${inflection.camelize(hookName)}Infinite`;\n\n            functions.push(\n              `\nexport const ${infiniteMethodName}QueryOptions = ${typeParamsDef}(${paramsDef}) => infiniteQueryOptions({\n  queryKey: ['${modelName}', '${methodName}', 'infinite'${paramNames ? `, ${paramNames}` : \"\"}],\n  queryFn: ({ pageParam }) => ${methodName}(${\n    paramNames ? paramNames.replace(/\\brawParams\\b/, \"{ ...rawParams, page: pageParam }\") : \"\"\n  }),\n  initialPageParam: 1 as number,\n  getNextPageParam: (lastPage, allPages) => {\n    const total = (lastPage as { total?: number })?.total ?? 0;\n    const loaded = allPages.reduce(\n      (sum, p) => sum + ((p as { rows?: unknown[] })?.rows?.length ?? 0),\n      0,\n    );\n    return loaded < total ? allPages.length + 1 : undefined;\n  },\n  select: dedupeAndFlatten,\n});\n          `.trim(),\n            );\n\n            functions.push(\n              `\nexport const ${infiniteHookName} = ${typeParamsDef}(${paramsDef}${\n                paramsDef ? \", \" : \"\"\n              }options?: { enabled?: boolean }) =>\n  useRefreshable(useInfiniteQuery({\n    ...${infiniteMethodName}QueryOptions(${paramNames}),\n    ...options\n  }));\n          `.trim(),\n            );\n          }\n        }\n\n        // 3. useMutation (tanstack-mutation)\n        if (clients.includes(\"tanstack-mutation\")) {\n          const hookName = inflection.camelize(api.methodName);\n          const mutationParamType =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext\n                  .map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, [])}`)\n                  .join(\", \")} }`\n              : \"void\";\n          const mutationParamNames =\n            paramsWithoutContext.length > 0\n              ? paramsWithoutContext.map((p) => `params.${p.name}`).join(\", \")\n              : \"\";\n\n          functions.push(\n            `\nexport const use${hookName}Mutation = ${typeParamsDef}() => useMutation({\n  mutationFn: (params: ${mutationParamType}) => ${modelName}Service.${methodName}(${mutationParamNames})\n});\n          `.trim(),\n          );\n        }\n\n        // 4. useMutation with multipart (tanstack-mutation-multipart)\n        if (clients.includes(\"tanstack-mutation-multipart\")) {\n          const hookName = inflection.camelize(api.methodName);\n\n          // 파라미터 타입 정의: paramsDef에서 타입만 추출\n          // paramsDef 예: \"params: { category: string }\" → \"{ category: string }\"\n          const paramsTypeDef =\n            paramsWithoutContext.length > 0\n              ? paramsDef.split(\":\").slice(1).join(\":\").trim() // \"params: { category: string }\" → \"{ category: string }\"\n              : \"\";\n\n          const mutationParamType =\n            paramsWithoutContext.length > 0\n              ? `{ params: ${paramsTypeDef}, files: File[] }`\n              : `{ files: File[] }`;\n\n          // mutationFn 호출 파라미터\n          const mutationFnCall =\n            paramsWithoutContext.length > 0\n              ? `${modelName}Service.${methodName}(params.params, params.files)`\n              : `${modelName}Service.${methodName}(params.files)`;\n\n          functions.push(\n            `\nexport const use${hookName}Mutation = ${typeParamsDef}(\n  options?: UseMutationOptions<${returnTypeDef}, Error, ${mutationParamType}> & {\n    onUploadProgress?: (e: AxiosProgressEvent) => void;\n  }\n) => useMutation({\n  mutationFn: (params: ${mutationParamType}) => ${mutationFnCall},\n  retry: false,\n  ...options,\n});\n          `.trim(),\n          );\n        }\n      }\n\n      namespaces.push(\n        `\nexport namespace ${modelName}Service {\n${functions.join(\"\\n\\n\")}\n}\n      `.trim(),\n      );\n    }\n\n    // AsyncIdConfig 생성 (Entity별로)\n    const entityIds = EntityManager.getAllIds();\n    const asyncIdConfigs: string[] = [];\n\n    for (const entityId of entityIds) {\n      const names = EntityManager.getNamesFromId(entityId);\n\n      // AsyncIdConfig용 리스트 조회 API 찾기\n      const listApi = apisByModel.get(names.capital)?.find((api) => {\n        // resourceName이 없거나 tanstack-query를 사용하지 않는 API는 제외\n        if (!api.options.resourceName || !api.options.clients?.includes(\"tanstack-query\")) {\n          return false;\n        }\n        // resourceName이 복수형이고 메서드명이 findMany인 API\n        const resourceName = api.options.resourceName;\n        return inflection.pluralize(resourceName) === resourceName && api.methodName === \"findMany\";\n      });\n\n      if (listApi) {\n        // resourceName에서 hook 이름 생성 (기존 로직과 동일)\n        const hookName = inflection.camelize(assertDefined(listApi.options.resourceName), true);\n        const useHookName = `use${inflection.camelize(hookName)}`;\n        const useHookInfiniteName = `${useHookName}Infinite`;\n\n        // ListParams 타입명 구성\n        const listParamsType = `${names.capital}ListParams`;\n\n        asyncIdConfigs.push(\n          `\n// AsyncIdConfig: ${names.capital}\nexport const ${names.capital}AsyncIdConfig: AsyncIdConfig<${names.capital}SubsetKey, ${names.capital}SubsetMapping, ${listParamsType}> = {\n  placeholderKey: \"entity.${names.capital}\",\n  useList: ${names.capital}Service.${useHookName},\n  useListInfinite: ${names.capital}Service.${useHookInfiniteName},\n};\n          `.trim(),\n        );\n      }\n    }\n\n    // BUILT_IN_TYPES에서 사용되는 타입들을 확인하여 동적으로 import 구성\n    const builtInTypeImports = Object.keys(BUILT_IN_TYPES)\n      .filter((typeKey) => importKeys.includes(typeKey))\n      .map((typeKey) => `type ${typeKey}`);\n\n    // sonamu.shared에서 import할 항목들을 동적으로 구성\n    // body 문자열을 기준으로 infinite 훅 생성 여부 판단 (findMany 복수형 분기에서만 참조됨)\n    const bodyForImportCheck = namespaces.join(\"\\n\\n\");\n    const needsDedupeAndFlatten = bodyForImportCheck.includes(\"dedupeAndFlatten\");\n    const needsUseRefreshable = bodyForImportCheck.includes(\"useRefreshable\");\n\n    const sonamuSharedImports = [\n      \"type ListResult\",\n      \"type FilterQuery\",\n      ...builtInTypeImports,\n      \"fetch\",\n      \"type EventHandlers\",\n      \"type SSEStreamOptions\",\n      \"type WebSocketChannelOptions\",\n      \"useSSEStream\",\n      \"useWebSocketChannel\",\n      \"toFormData\",\n      ...(needsDedupeAndFlatten ? [\"dedupeAndFlatten\"] : []),\n      ...(needsUseRefreshable ? [\"useRefreshable\"] : []),\n    ].join(\", \");\n\n    // body 구성: namespaces + asyncIdConfigs\n    const bodyParts = [...namespaces, ...asyncIdConfigs];\n\n    return {\n      ...this.getTargetAndPath(),\n      body: bodyParts.join(\"\\n\\n\"),\n      importKeys: diff(unique(importKeys), [\n        ...typeParamNames,\n        \"ListResult\",\n        ...Object.keys(BUILT_IN_TYPES),\n      ]),\n      customHeaders: [\n        \"/**\",\n        \" * @generated\",\n        \" * 직접 수정하지 마세요.\",\n        \" */\",\n        \"\",\n        \"/* oxlint-disable */\",\n        \"\",\n        `import { queryOptions, useQuery, useInfiniteQuery, infiniteQueryOptions, useMutation, type UseMutationOptions } from '@tanstack/react-query';`,\n        `import { type AxiosProgressEvent } from 'axios';`,\n        `import qs from 'qs';`,\n        `import { ${sonamuSharedImports} } from './sonamu.shared';`,\n        `import { type AsyncIdConfig } from '@sonamu-kit/react-components/components';`,\n      ],\n    };\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sonamu",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "description": "Sonamu — TypeScript Fullstack API Framework",
   "keywords": [
     "framework",
@@ -130,8 +130,8 @@
     "vite": "8.0.16",
     "vitest": "^4.1.9",
     "@sonamu-kit/hmr-hook": "^0.5.1",
-    "@sonamu-kit/hmr-runner": "^0.2.0",
     "@sonamu-kit/tasks": "^0.3.1",
+    "@sonamu-kit/hmr-runner": "^0.2.0",
     "@sonamu-kit/ts-loader": "^2.2.0"
   },
   "devDependencies": {

package/src/api/decorators.ts

@@ -396,9 +396,7 @@ export function transactional(options: TransactionalOptions = {}) {
         method: methodName,
       });
 
-      const existingContext = DB.transactionStorage.getStore();
-
-      // AsyncLocalStorage 컨텍스트 없거나 해당 preset의 트랜잭션이 없으면 새로 시작
+      // 해당 preset의 트랜잭션이 없으면 새 트랜잭션과 scope를 함께 시작한다.
       const startTransaction = async () => {
         const puri = this.getPuri(dbPreset);
 
@@ -406,33 +404,24 @@ export function transactional(options: TransactionalOptions = {}) {
           async (trx) => {
             this.logger.debug("new transaction context: {dbPreset}", { dbPreset });
             const trxWrapper = new PuriTransactionWrapper(trx, new UpsertBuilder());
-            // TransactionContext에 트랜잭션 저장
-            DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);
-
-            try {
-              return await originalMethod.apply(this, args);
-            } finally {
-              // 트랜잭션 제거
-              this.logger.debug("delete transaction context: {dbPreset}", { dbPreset });
-              DB.getTransactionContext().deleteTransaction(dbPreset);
-            }
+
+            return DB.runWithTransactionScope(dbPreset, trxWrapper, () =>
+              originalMethod.apply(this, args),
+            );
           },
           { isolationLevel: isolation, readOnly },
         );
       };
 
-      // AsyncLocalStorage 컨텍스트가 없으면 새로 생성
-      if (!existingContext) {
-        return DB.runWithTransaction(startTransaction);
-      }
-
-      // 이미 AsyncLocalStorage 컨텍스트 안에 있는지 확인 후 해당 preset의 트랜잭션이 이미 있으면 재사용
-      if (existingContext?.getTransaction(dbPreset)) {
+      const existingTransaction = DB.transactionStorage.getStore()?.getTransaction(dbPreset);
+      if (existingTransaction) {
         this.logger.debug("reuse transaction context: {dbPreset}", { dbPreset });
-        return originalMethod.apply(this, args);
+        // 다른 preset이 안쪽에 있어도 이 메서드가 재사용한 트랜잭션을 현재 scope로 표시한다.
+        return DB.runWithTransactionScope(dbPreset, existingTransaction, () =>
+          originalMethod.apply(this, args),
+        );
       }
 
-      // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)
       return startTransaction();
     };
 

package/src/database/__tests__/transaction-scope.test.ts

@@ -0,0 +1,227 @@
+import { type Knex } from "knex";
+import { describe, expect, it } from "vitest";
+
+import { type DBPreset, DBClass } from "../db";
+import { PuriTransactionWrapper } from "../puri-wrapper";
+import { UpsertBuilder } from "../upsert-builder";
+
+type TransactionScopeDB = DBClass & {
+  runWithTransactionScope?<T>(
+    preset: DBPreset,
+    transaction: PuriTransactionWrapper,
+    callback: () => Promise<T>,
+  ): Promise<T>;
+};
+
+function createTransactionWrapper(): PuriTransactionWrapper {
+  return new PuriTransactionWrapper({} as Knex.Transaction, new UpsertBuilder());
+}
+
+function createDeferred() {
+  let resolve!: () => void;
+  const promise = new Promise<void>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+
+function expectScopeRunner(db: TransactionScopeDB) {
+  expect(db.runWithTransactionScope).toBeTypeOf("function");
+  return db.runWithTransactionScope;
+}
+
+describe("DB.runWithTransactionScope", () => {
+  it("저장소가 없어도 루트 scope를 설치하고 콜백 결과를 반환한 뒤 정리한다", async () => {
+    const db = new DBClass() as TransactionScopeDB;
+    const transaction = createTransactionWrapper();
+    const runScope = expectScopeRunner(db);
+    if (!runScope) return;
+
+    let callbackContext: ReturnType<DBClass["getTransactionContext"]> | undefined;
+    const result = await runScope.call(db, "w", transaction, async () => {
+      callbackContext = db.getTransactionContext();
+      expect(db.transactionStorage.getStore()).toBe(callbackContext);
+      expect(callbackContext.getActiveTransaction()).toBe(transaction);
+      expect(callbackContext.getTransaction("w")).toBe(transaction);
+      return "완료";
+    });
+
+    expect(result).toBe("완료");
+    expect(callbackContext?.getActiveTransaction()).toBeUndefined();
+    expect(callbackContext?.getTransaction("w")).toBeUndefined();
+    expect(db.transactionStorage.getStore()).toBeUndefined();
+  });
+
+  it("scope 안에서 생성된 detached descendant가 완료된 자식 트랜잭션을 다시 사용하지 않는다", async () => {
+    const db = new DBClass() as TransactionScopeDB;
+    const parentTransaction = createTransactionWrapper();
+    const childTransaction = createTransactionWrapper();
+    const descendantReady = createDeferred();
+    const resumeDescendant = createDeferred();
+    const runScope = expectScopeRunner(db);
+    if (!runScope) return;
+
+    let parentContext: ReturnType<DBClass["getTransactionContext"]> | undefined;
+    let childContext: ReturnType<DBClass["getTransactionContext"]> | undefined;
+
+    await runScope.call(db, "r", parentTransaction, async () => {
+      parentContext = db.getTransactionContext();
+
+      let descendantPromise:
+        | Promise<{
+            context: ReturnType<DBClass["getTransactionContext"]>;
+            active: PuriTransactionWrapper | undefined;
+            write: PuriTransactionWrapper | undefined;
+            read: PuriTransactionWrapper | undefined;
+          }>
+        | undefined;
+
+      childContext = await runScope.call(db, "w", childTransaction, async () => {
+        const scopedContext = db.getTransactionContext();
+        descendantPromise = (async () => {
+          descendantReady.resolve();
+          await resumeDescendant.promise;
+          const context = db.getTransactionContext();
+          return {
+            context,
+            active: context.getActiveTransaction(),
+            write: context.getTransaction("w"),
+            read: context.getTransaction("r"),
+          };
+        })();
+
+        await descendantReady.promise;
+        return scopedContext;
+      });
+
+      expect(db.getTransactionContext()).toBe(parentContext);
+      expect(childContext.getActiveTransaction()).toBe(parentTransaction);
+      expect(childContext.getTransaction("w")).toBeUndefined();
+      expect(childContext.getTransaction("r")).toBe(parentTransaction);
+
+      resumeDescendant.resolve();
+      if (!descendantPromise) {
+        throw new Error("detached descendant가 생성되지 않았습니다");
+      }
+      const descendantResult = await descendantPromise;
+
+      expect(descendantResult.context).toBe(childContext);
+      expect(descendantResult.active).toBe(parentTransaction);
+      expect(descendantResult.write).toBeUndefined();
+      expect(descendantResult.read).toBe(parentTransaction);
+    });
+
+    expect(parentContext?.getActiveTransaction()).toBeUndefined();
+    expect(parentContext?.getTransaction("r")).toBeUndefined();
+    expect(childContext?.getActiveTransaction()).toBeUndefined();
+    expect(childContext?.getTransaction("r")).toBeUndefined();
+    expect(db.transactionStorage.getStore()).toBeUndefined();
+  });
+
+  it("같거나 다른 preset의 중첩 범위를 복원하고 같은 오류를 다시 던진다", async () => {
+    const db = new DBClass() as TransactionScopeDB;
+    const outer = createTransactionWrapper();
+    const samePresetInner = createTransactionWrapper();
+    const differentPresetInner = createTransactionWrapper();
+    const expectedError = new Error("의도한 scope 오류");
+    const runScope = expectScopeRunner(db);
+    if (!runScope) return;
+
+    await runScope.call(db, "w", outer, async () => {
+      const outerContext = db.getTransactionContext();
+      expect(outerContext.getActiveTransaction()).toBe(outer);
+
+      await runScope.call(db, "w", samePresetInner, async () => {
+        expect(db.getTransactionContext().getActiveTransaction()).toBe(samePresetInner);
+        expect(db.getTransactionContext().getTransaction("w")).toBe(samePresetInner);
+      });
+      expect(db.getTransactionContext()).toBe(outerContext);
+      expect(outerContext.getActiveTransaction()).toBe(outer);
+
+      await expect(
+        runScope.call(db, "fixture", differentPresetInner, async () => {
+          const innerContext = db.getTransactionContext();
+          expect(innerContext.getActiveTransaction()).toBe(differentPresetInner);
+          expect(innerContext.getTransaction("w")).toBe(outer);
+          expect(innerContext.getTransaction("fixture")).toBe(differentPresetInner);
+          throw expectedError;
+        }),
+      ).rejects.toBe(expectedError);
+
+      expect(db.getTransactionContext()).toBe(outerContext);
+      expect(outerContext.getActiveTransaction()).toBe(outer);
+      expect(outerContext.getTransaction("fixture")).toBeUndefined();
+    });
+
+    expect(db.transactionStorage.getStore()).toBeUndefined();
+  });
+
+  it("겹치는 sibling 범위가 완료 순서와 무관하게 서로의 활성 트랜잭션을 보지 않는다", async () => {
+    const db = new DBClass() as TransactionScopeDB;
+    const parentTransaction = createTransactionWrapper();
+    const firstTransaction = createTransactionWrapper();
+    const secondTransaction = createTransactionWrapper();
+    const firstReady = createDeferred();
+    const secondReady = createDeferred();
+    const firstExited = createDeferred();
+    const runScope = expectScopeRunner(db);
+    if (!runScope) return;
+
+    let firstContext: ReturnType<DBClass["getTransactionContext"]> | undefined;
+    let secondContext: ReturnType<DBClass["getTransactionContext"]> | undefined;
+
+    await runScope.call(db, "r", parentTransaction, async () => {
+      const parentContext = db.getTransactionContext();
+      const firstPromise = runScope.call(db, "w", firstTransaction, async () => {
+        firstReady.resolve();
+        await secondReady.promise;
+        return {
+          context: db.getTransactionContext(),
+          active: db.getTransactionContext().getActiveTransaction(),
+          write: db.getTransactionContext().getTransaction("w"),
+          inheritedRead: db.getTransactionContext().getTransaction("r"),
+        };
+      });
+
+      await firstReady.promise;
+      const secondPromise = runScope.call(db, "w", secondTransaction, async () => {
+        secondReady.resolve();
+        await firstExited.promise;
+        return {
+          context: db.getTransactionContext(),
+          active: db.getTransactionContext().getActiveTransaction(),
+          write: db.getTransactionContext().getTransaction("w"),
+          inheritedRead: db.getTransactionContext().getTransaction("r"),
+        };
+      });
+
+      const firstResult = await firstPromise;
+      firstExited.resolve();
+      const secondResult = await secondPromise;
+      firstContext = firstResult.context;
+      secondContext = secondResult.context;
+
+      expect(firstResult.context).not.toBe(secondResult.context);
+      expect(firstResult.active).toBe(firstTransaction);
+      expect(firstResult.write).toBe(firstTransaction);
+      expect(firstResult.inheritedRead).toBe(parentTransaction);
+      expect(secondResult.active).toBe(secondTransaction);
+      expect(secondResult.write).toBe(secondTransaction);
+      expect(secondResult.inheritedRead).toBe(parentTransaction);
+      expect(firstResult.context.getActiveTransaction()).toBe(parentTransaction);
+      expect(secondResult.context.getActiveTransaction()).toBe(parentTransaction);
+      expect(db.getTransactionContext()).toBe(parentContext);
+      expect(parentContext.getActiveTransaction()).toBe(parentTransaction);
+    });
+
+    expect(firstContext?.getActiveTransaction()).toBeUndefined();
+    expect(secondContext?.getActiveTransaction()).toBeUndefined();
+    expect(db.transactionStorage.getStore()).toBeUndefined();
+  });
+
+  it("기존 bootstrap helper를 런타임 API로 노출하지 않는다", () => {
+    const db = new DBClass();
+
+    expect(db).not.toHaveProperty("runWithTransaction");
+  });
+});

package/src/database/base-model.ts

@@ -67,6 +67,15 @@ export class BaseModelClass<
     return new PuriWrapper(db, new UpsertBuilder());
   }
 
+  private getSubsetQueryPuri(): PuriWrapper {
+    const activeTransaction = DB.getTransactionContext().getActiveTransaction();
+    if (activeTransaction) {
+      return activeTransaction;
+    }
+
+    return new PuriWrapper(this.getDB("r"), new UpsertBuilder());
+  }
+
   async destroy() {
     return DB.destroy();
   }
@@ -120,7 +129,7 @@ export class BaseModelClass<
       throw new Error("subsetQueries is not defined");
     }
 
-    const puriWrapper = new PuriWrapper(this.getDB("r"), new UpsertBuilder());
+    const puriWrapper = this.getSubsetQueryPuri();
     const qb = this.subsetQueries[subset]?.(puriWrapper);
 
     // NonAllowedAsSingleTable: 단일 테이블 컬럼 접근 방지용 마커
@@ -201,6 +210,8 @@ export class BaseModelClass<
     }
 
     const { num, page } = queryParams;
+    // 모든 로더가 root query와 같은 연결을 사용하도록 실행 시점의 knex에서 한 번만 파생한다.
+    const puriWrapper = new PuriWrapper(qb.knex, new UpsertBuilder());
 
     // COUNT 쿼리 실행 (queryMode: list일 때는 0 리턴)
     const total = await this.executeCountQuery(qb, queryParams, debug, optimizeCountQuery);
@@ -210,7 +221,15 @@ export class BaseModelClass<
     }
 
     // LIST 쿼리 실행
-    const computedRows = await this.executeListQuery(subset, qb, queryParams, num, page, debug);
+    const computedRows = await this.executeListQuery(
+      subset,
+      qb,
+      queryParams,
+      num,
+      page,
+      debug,
+      puriWrapper,
+    );
 
     // Enhancer 적용
     const enhancer = (params as any).enhancers?.[subset];
@@ -457,6 +476,7 @@ export class BaseModelClass<
     num: number,
     page: number,
     debug: boolean,
+    puriWrapper: PuriWrapper,
   ): Promise<any[]> {
     if (params.queryMode === "count") {
       return [];
@@ -478,7 +498,7 @@ export class BaseModelClass<
     // 로더 처리
     const loaders = (this.loaderQueries as any)[subset];
     if (loaders && Array.isArray(loaders)) {
-      unloadedRows = await this.processLoaders(unloadedRows, loaders, debug);
+      unloadedRows = await this.processLoaders(unloadedRows, loaders, debug, puriWrapper);
     }
 
     return this.hydrate(unloadedRows);
@@ -487,12 +507,17 @@ export class BaseModelClass<
   /**
    * 재귀적 로더 처리
    */
-  private async processLoaders(rows: any[], loaders: any[], debug: boolean): Promise<any[]> {
+  private async processLoaders(
+    rows: any[],
+    loaders: any[],
+    debug: boolean,
+    puriWrapper: PuriWrapper,
+  ): Promise<any[]> {
     for (const resolveLoader of loaders) {
       const { as, refId, qb: resolveLoaderQbFn, loaders: nestedLoaders } = resolveLoader;
 
       const resolveLoaderQb = resolveLoaderQbFn(
-        new PuriWrapper(this.getDB("r"), new UpsertBuilder()),
+        puriWrapper,
         rows.map((row) => row[refId]),
       );
 
@@ -504,7 +529,7 @@ export class BaseModelClass<
 
       // 중첩 loaders가 있으면 재귀 처리
       if (nestedLoaders && nestedLoaders.length > 0) {
-        loadedRows = await this.processLoaders(loadedRows, nestedLoaders, debug);
+        loadedRows = await this.processLoaders(loadedRows, nestedLoaders, debug, puriWrapper);
       }
 
       const subRowGroups = group(loadedRows, (row) => row.refId);

package/src/database/db.ts

@@ -6,6 +6,7 @@ import { type Knex } from "knex";
 import { type DatabaseConfig, type SonamuConfig } from "../api/config";
 import { getSonamuEnvironment, type EnvironmentSnapshots, type SonamuEnvironment } from "../env";
 import { createKnexInstance } from "./knex";
+import { type PuriTransactionWrapper } from "./puri-wrapper";
 import { TransactionContext } from "./transaction-context";
 
 function isPlainObject(value: unknown): value is Record<string, unknown> {
@@ -155,8 +156,22 @@ export class DBClass {
 
   public transactionStorage = new AsyncLocalStorage<TransactionContext>();
 
-  public runWithTransaction<T>(callback: () => Promise<T>): Promise<T> {
-    return this.transactionStorage.run(new TransactionContext(), callback);
+  public runWithTransactionScope<T>(
+    preset: DBPreset,
+    transaction: PuriTransactionWrapper,
+    callback: () => Promise<T>,
+  ): Promise<T> {
+    const parentContext = this.transactionStorage.getStore();
+    const transactionContext = new TransactionContext(parentContext, { preset, transaction });
+
+    return this.transactionStorage.run(transactionContext, async () => {
+      try {
+        return await callback();
+      } finally {
+        // detached descendant가 완료된 트랜잭션을 다시 사용하지 않도록 local scope를 비운다.
+        transactionContext.clearLocal();
+      }
+    });
   }
 
   setConfig(dbConfig: SonamuDBConfig): void {