sonamu 0.8.26 → 0.9.0

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

@@ -1,96 +1,91 @@
+import { assertDefined, init_utils } from "../../utils/utils.js";
+import { Sonamu, init_sonamu } from "../../api/sonamu.js";
+import { ApiParamType, init_types } from "../../types/types.js";
+import { EntityManager, init_entity_manager } from "../../entity/entity-manager.js";
+import { apiParamToTsCode, apiParamTypeToTsType, init_code_converters, unwrapPromiseOnce } from "../../api/code-converters.js";
+import { Template, init_template } from "../template.js";
+import { BUILT_IN_TYPES, init_zod_converter, zodTypeToTsTypeDef } from "../zod-converter.js";
 import inflection from "inflection";
 import { diff, unique } from "radashi";
-import { apiParamToTsCode, apiParamTypeToTsType, unwrapPromiseOnce } from "../../api/code-converters.js";
-import { Sonamu } from "../../api/sonamu.js";
-import { EntityManager } from "../../entity/entity-manager.js";
-import { ApiParamType } from "../../types/types.js";
-import { assertDefined } from "../../utils/utils.js";
-import { Template } from "../template.js";
-import { BUILT_IN_TYPES, zodTypeToTsTypeDef } from "../zod-converter.js";
-export class Template__services extends Template {
-    constructor(){
-        super("services");
-    }
-    getTargetAndPath() {
-        return {
-            target: ":target/src/services",
-            path: `services.generated.ts`
-        };
-    }
-    render({}) {
-        const { apis } = Sonamu.syncer;
-        // 모델별로 그룹화
-        const apisByModel = new Map();
-        for (const api of apis){
-            const modelName = api.modelName.replace(/Model$/, "").replace(/Frame$/, "");
-            if (!apisByModel.has(modelName)) {
-                apisByModel.set(modelName, []);
-            }
-            apisByModel.get(modelName)?.push(api);
-        }
-        const importKeys = [];
-        const namespaces = [];
-        let typeParamNames = [];
-        for (const [modelName, modelApis] of apisByModel){
-            const functions = [];
-            for (const api of modelApis){
-                // @stream 데코레이터가 있으면 SSE 스트림 함수 생성
-                if (api.streamOptions) {
-                    const paramsWithoutContext = api.parameters.filter((param)=>!ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional === true && param.name.startsWith("_")));
-                    const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;
-                    const methodNameStream = api.options.resourceName ? `use${inflection.camelize(api.options.resourceName)}` : `use${inflection.camelize(api.methodName)}`;
-                    const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);
-                    const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);
-                    // 파라미터를 객체 형태로 정의 (타입과 실제 값 모두에 사용)
-                    const paramsDefAsObject = paramsWithoutContext.length > 0 ? `{ ${paramsWithoutContext.map((p)=>`${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(", ")} }` : "{}";
-                    functions.push(`
+
+//#region src/template/implementations/services.template.ts
+init_code_converters();
+init_sonamu();
+init_entity_manager();
+init_types();
+init_utils();
+init_template();
+init_zod_converter();
+var Template__services = class extends Template {
+	constructor() {
+		super("services");
+	}
+	getTargetAndPath() {
+		return {
+			target: ":target/src/services",
+			path: `services.generated.ts`
+		};
+	}
+	render({}) {
+		const { apis } = Sonamu.syncer;
+		const apisByModel = new Map();
+		for (const api of apis) {
+			const modelName = api.modelName.replace(/Model$/, "").replace(/Frame$/, "");
+			if (!apisByModel.has(modelName)) {
+				apisByModel.set(modelName, []);
+			}
+			apisByModel.get(modelName)?.push(api);
+		}
+		const importKeys = [];
+		const namespaces = [];
+		let typeParamNames = [];
+		for (const [modelName, modelApis] of apisByModel) {
+			const functions = [];
+			for (const api of modelApis) {
+				if (api.streamOptions) {
+					const paramsWithoutContext$1 = api.parameters.filter((param) => !ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional && param.name.startsWith("_")));
+					const apiBaseUrl$1 = `${Sonamu.config.api.route.prefix}${api.path}`;
+					const methodNameStream = api.options.resourceName ? `use${inflection.camelize(api.options.resourceName)}` : `use${inflection.camelize(api.methodName)}`;
+					const methodNameStreamCamelized = inflection.camelize(methodNameStream, true);
+					const eventsTypeDef = zodTypeToTsTypeDef(api.streamOptions.events);
+					const paramsDefAsObject = paramsWithoutContext$1.length > 0 ? `{ ${paramsWithoutContext$1.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(", ")} }` : "{}";
+					functions.push(`
 export function ${methodNameStreamCamelized}(
   params: ${paramsDefAsObject},
   handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,
   options: SSEStreamOptions
 ) {
-  return useSSEStream<${eventsTypeDef}>(\`${apiBaseUrl}\`, params, handlers, options);
+  return useSSEStream<${eventsTypeDef}>(\`${apiBaseUrl$1}\`, params, handlers, options);
 }
             `.trim());
-                    continue;
-                }
-                // Context 제외한 파라미터
-                const paramsWithoutContext = api.parameters.filter((param)=>!ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional === true && param.name.startsWith("_")));
-                // 타입 파라미터 정의
-                const typeParametersAsTsType = api.typeParameters.map((typeParam)=>apiParamTypeToTsType(typeParam, importKeys)).join(", ");
-                const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : "";
-                typeParamNames = typeParamNames.concat(api.typeParameters.map((tp)=>tp.id));
-                // 파라미터 정의
-                const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);
-                const paramNames = paramsWithoutContext.map((p)=>p.name).join(", ");
-                // 리턴 타입 정의
-                const returnTypeDef = apiParamTypeToTsType(assertDefined(unwrapPromiseOnce(api.returnType)), importKeys);
-                // 기본 URL
-                const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;
-                const clients = api.options.clients || [];
-                // 1. axios 함수 생성
-                // resourceName이 있으면 get + resourceName 형태로 함수명 생성
-                const methodName = api.options.resourceName ? `get${inflection.camelize(api.options.resourceName)}` : api.methodName;
-                // axios-multipart 처리 (파일 업로드)
-                if (clients.includes("axios-multipart")) {
-                    const formDataAppend = `files.forEach(f => { formData.append("files", f); });`;
-                    const otherParamsAppend = paramsWithoutContext.map((param)=>{
-                        // primitive 타입인지 체크
-                        const isPrimitive = typeof param.type === "string" && [
-                            "string",
-                            "number",
-                            "boolean"
-                        ].includes(param.type);
-                        if (isPrimitive) {
-                            // primitive: 직접 formData.append
-                            return `formData.append('${param.name}', String(${param.name}));`;
-                        } else {
-                            // object: toFormData 사용
-                            return `toFormData(${param.name}, formData, '${param.name}');`;
-                        }
-                    }).join("\n    ");
-                    const paramsDefComma = paramsDef !== "" ? ", " : "";
-                    functions.push(`
+					continue;
+				}
+				const paramsWithoutContext = api.parameters.filter((param) => !ApiParamType.isContext(param.type) && !ApiParamType.isRefKnex(param.type) && !(param.optional && param.name.startsWith("_")));
+				const typeParametersAsTsType = api.typeParameters.map((typeParam) => apiParamTypeToTsType(typeParam, importKeys)).join(", ");
+				const typeParamsDef = typeParametersAsTsType ? `<${typeParametersAsTsType}>` : "";
+				typeParamNames = typeParamNames.concat(api.typeParameters.map((tp) => tp.id));
+				const paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);
+				const paramNames = paramsWithoutContext.map((p) => p.name).join(", ");
+				const returnTypeDef = apiParamTypeToTsType(assertDefined(unwrapPromiseOnce(api.returnType)), importKeys);
+				const apiBaseUrl = `${Sonamu.config.api.route.prefix}${api.path}`;
+				const clients = api.options.clients || [];
+				const methodName = api.options.resourceName ? `get${inflection.camelize(api.options.resourceName)}` : api.methodName;
+				if (clients.includes("axios-multipart")) {
+					const formDataAppend = `files.forEach(f => { formData.append("files", f); });`;
+					const otherParamsAppend = paramsWithoutContext.map((param) => {
+						const isPrimitive = typeof param.type === "string" && [
+							"string",
+							"number",
+							"boolean"
+						].includes(param.type);
+						if (isPrimitive) {
+							return `formData.append('${param.name}', String(${param.name}));`;
+						} else {
+							return `toFormData(${param.name}, formData, '${param.name}');`;
+						}
+					}).join("\n    ");
+					const paramsDefComma = paramsDef !== "" ? ", " : "";
+					functions.push(`
 export async function ${methodName}${typeParamsDef}(
   ${paramsDef}${paramsDefComma}
   files: File[],
@@ -108,9 +103,9 @@ export async function ${methodName}${typeParamsDef}(
   });
 }
           `.trim());
-                } else if (api.options.httpMethod === "GET") {
-                    const hasParams = paramsWithoutContext.length > 0;
-                    functions.push(`
+				} else if (api.options.httpMethod === "GET") {
+					const hasParams = paramsWithoutContext.length > 0;
+					functions.push(`
 export async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
   return fetch({
     method: "GET",
@@ -119,9 +114,9 @@ export async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${ret
   });
 }
           `.trim());
-                } else {
-                    const hasParams = paramsWithoutContext.length > 0;
-                    functions.push(`
+				} else {
+					const hasParams = paramsWithoutContext.length > 0;
+					functions.push(`
 export async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
   return fetch({
     method: "${api.options.httpMethod}",
@@ -131,48 +126,39 @@ export async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${ret
   });
 }
           `.trim());
-                }
-                // 2. queryOptions + useQuery (tanstack-query)
-                if (clients.includes("tanstack-query")) {
-                    const hookName = api.options.resourceName ? inflection.camelize(api.options.resourceName, true) : inflection.camelize(api.methodName, true);
-                    // queryOptions
-                    functions.push(`
+				}
+				if (clients.includes("tanstack-query")) {
+					const hookName = api.options.resourceName ? inflection.camelize(api.options.resourceName, true) : inflection.camelize(api.methodName, true);
+					functions.push(`
 export const ${methodName}QueryOptions = ${typeParamsDef}(${paramsDef}) => queryOptions({
   queryKey: ['${modelName}', '${methodName}'${paramNames ? `, ${paramNames}` : ""}],
   queryFn: () => ${methodName}(${paramNames})
 });
           `.trim());
-                    // useQuery hook
-                    functions.push(`
+					functions.push(`
 export const use${inflection.camelize(hookName)} = ${typeParamsDef}(${paramsDef}${paramsDef ? ", " : ""}options?: { enabled?: boolean }) =>
   useQuery({
     ...${methodName}QueryOptions(${paramNames}),
     ...options
   });
           `.trim());
-                }
-                // 3. useMutation (tanstack-mutation)
-                if (clients.includes("tanstack-mutation")) {
-                    const hookName = inflection.camelize(api.methodName);
-                    const mutationParamType = paramsWithoutContext.length > 0 ? `{ ${paramsWithoutContext.map((p)=>`${p.name}: ${apiParamTypeToTsType(p.type, [])}`).join(", ")} }` : "void";
-                    const mutationParamNames = paramsWithoutContext.length > 0 ? paramsWithoutContext.map((p)=>`params.${p.name}`).join(", ") : "";
-                    functions.push(`
+				}
+				if (clients.includes("tanstack-mutation")) {
+					const hookName = inflection.camelize(api.methodName);
+					const mutationParamType = paramsWithoutContext.length > 0 ? `{ ${paramsWithoutContext.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, [])}`).join(", ")} }` : "void";
+					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})
 });
           `.trim());
-                }
-                // 4. useMutation with multipart (tanstack-mutation-multipart)
-                if (clients.includes("tanstack-mutation-multipart")) {
-                    const hookName = inflection.camelize(api.methodName);
-                    // 파라미터 타입 정의: paramsDef에서 타입만 추출
-                    // paramsDef 예: "params: { category: string }" → "{ category: string }"
-                    const paramsTypeDef = paramsWithoutContext.length > 0 ? paramsDef.split(":").slice(1).join(":").trim() // "params: { category: string }" → "{ category: string }"
-                     : "";
-                    const mutationParamType = paramsWithoutContext.length > 0 ? `{ params: ${paramsTypeDef}, files: File[] }` : `{ files: File[] }`;
-                    // mutationFn 호출 파라미터
-                    const mutationFnCall = paramsWithoutContext.length > 0 ? `${methodName}(params.params, params.files)` : `${methodName}(params.files)`;
-                    functions.push(`
+				}
+				if (clients.includes("tanstack-mutation-multipart")) {
+					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)`;
+					functions.push(`
 export const use${hookName}Mutation = ${typeParamsDef}(
   options?: UseMutationOptions<${returnTypeDef}, Error, ${mutationParamType}> & {
     onUploadProgress?: (e: AxiosProgressEvent) => void;
@@ -183,86 +169,75 @@ export const use${hookName}Mutation = ${typeParamsDef}(
   ...options,
 });
           `.trim());
-                }
-            }
-            namespaces.push(`
+				}
+			}
+			namespaces.push(`
 export namespace ${modelName}Service {
 ${functions.join("\n\n")}
 }
       `.trim());
-        }
-        // AsyncIdConfig 생성 (Entity별로)
-        const entityIds = EntityManager.getAllIds();
-        const asyncIdConfigs = [];
-        for (const entityId of entityIds){
-            const names = EntityManager.getNamesFromId(entityId);
-            // AsyncIdConfig용 리스트 조회 API 찾기
-            const listApi = apisByModel.get(names.capital)?.find((api)=>{
-                // resourceName이 없거나 tanstack-query를 사용하지 않는 API는 제외
-                if (!api.options.resourceName || !api.options.clients?.includes("tanstack-query")) {
-                    return false;
-                }
-                // resourceName이 복수형이고 메서드명이 findMany인 API
-                const resourceName = api.options.resourceName;
-                return inflection.pluralize(resourceName) === resourceName && api.methodName === "findMany";
-            });
-            if (listApi) {
-                // resourceName에서 hook 이름 생성 (기존 로직과 동일)
-                const hookName = inflection.camelize(assertDefined(listApi.options.resourceName), true);
-                const useHookName = `use${inflection.camelize(hookName)}`;
-                // ListParams 타입명 구성
-                const listParamsType = `${names.capital}ListParams`;
-                asyncIdConfigs.push(`
+		}
+		const entityIds = EntityManager.getAllIds();
+		const asyncIdConfigs = [];
+		for (const entityId of entityIds) {
+			const names = EntityManager.getNamesFromId(entityId);
+			const listApi = apisByModel.get(names.capital)?.find((api) => {
+				if (!api.options.resourceName || !api.options.clients?.includes("tanstack-query")) {
+					return false;
+				}
+				const resourceName = api.options.resourceName;
+				return inflection.pluralize(resourceName) === resourceName && api.methodName === "findMany";
+			});
+			if (listApi) {
+				const hookName = inflection.camelize(assertDefined(listApi.options.resourceName), true);
+				const useHookName = `use${inflection.camelize(hookName)}`;
+				const listParamsType = `${names.capital}ListParams`;
+				asyncIdConfigs.push(`
 // AsyncIdConfig: ${names.capital}
 export const ${names.capital}AsyncIdConfig: AsyncIdConfig<${names.capital}SubsetKey, ${names.capital}SubsetMapping, ${listParamsType}> = {
   placeholderKey: "entity.${names.capital}",
   useList: ${names.capital}Service.${useHookName},
 };
           `.trim());
-            }
-        }
-        // BUILT_IN_TYPES에서 사용되는 타입들을 확인하여 동적으로 import 구성
-        const builtInTypeImports = Object.keys(BUILT_IN_TYPES).filter((typeKey)=>importKeys.includes(typeKey)).map((typeKey)=>`type ${typeKey}`);
-        // sonamu.shared에서 import할 항목들을 동적으로 구성
-        const sonamuSharedImports = [
-            "type ListResult",
-            "type FilterQuery",
-            ...builtInTypeImports,
-            "fetch",
-            "type EventHandlers",
-            "type SSEStreamOptions",
-            "useSSEStream",
-            "toFormData"
-        ].join(", ");
-        // body 구성: namespaces + asyncIdConfigs
-        const bodyParts = [
-            ...namespaces,
-            ...asyncIdConfigs
-        ];
-        return {
-            ...this.getTargetAndPath(),
-            body: bodyParts.join("\n\n"),
-            importKeys: diff(unique(importKeys), [
-                ...typeParamNames,
-                "ListResult",
-                ...Object.keys(BUILT_IN_TYPES)
-            ]),
-            customHeaders: [
-                "/**",
-                " * @generated",
-                " * 직접 수정하지 마세요.",
-                " */",
-                "/** biome-ignore-all lint: generated는 무시 */",
-                "/** biome-ignore-all assist: generated는 무시 */",
-                "",
-                `import { queryOptions, useQuery, useMutation, type UseMutationOptions } from '@tanstack/react-query';`,
-                `import type { AxiosProgressEvent } from 'axios';`,
-                `import qs from 'qs';`,
-                `import { ${sonamuSharedImports} } from './sonamu.shared';`,
-                `import type { AsyncIdConfig } from '@sonamu-kit/react-components/components';`
-            ]
-        };
-    }
-}
+			}
+		}
+		const builtInTypeImports = Object.keys(BUILT_IN_TYPES).filter((typeKey) => importKeys.includes(typeKey)).map((typeKey) => `type ${typeKey}`);
+		const sonamuSharedImports = [
+			"type ListResult",
+			"type FilterQuery",
+			...builtInTypeImports,
+			"fetch",
+			"type EventHandlers",
+			"type SSEStreamOptions",
+			"useSSEStream",
+			"toFormData"
+		].join(", ");
+		const bodyParts = [...namespaces, ...asyncIdConfigs];
+		return {
+			...this.getTargetAndPath(),
+			body: bodyParts.join("\n\n"),
+			importKeys: diff(unique(importKeys), [
+				...typeParamNames,
+				"ListResult",
+				...Object.keys(BUILT_IN_TYPES)
+			]),
+			customHeaders: [
+				"/**",
+				" * @generated",
+				" * 직접 수정하지 마세요.",
+				" */",
+				"/* oxlint-disable */",
+				"",
+				`import { queryOptions, useQuery, useMutation, type UseMutationOptions } from '@tanstack/react-query';`,
+				`import type { AxiosProgressEvent } from 'axios';`,
+				`import qs from 'qs';`,
+				`import { ${sonamuSharedImports} } from './sonamu.shared';`,
+				`import type { AsyncIdConfig } from '@sonamu-kit/react-components/components';`
+			]
+		};
+	}
+};
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/services.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { diff, unique } from \"radashi\";\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\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 === true && 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        // Context 제외한 파라미터\n        const paramsWithoutContext = api.parameters.filter(\n          (param) =>\n            !ApiParamType.isContext(param.type) &&\n            !ApiParamType.isRefKnex(param.type) &&\n            !(param.optional === true && 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\n          functions.push(\n            `\nexport const use${inflection.camelize(hookName)} = ${typeParamsDef}(${paramsDef}${\n              paramsDef ? \", \" : \"\"\n            }options?: { enabled?: boolean }) =>\n  useQuery({\n    ...${methodName}QueryOptions(${paramNames}),\n    ...options\n  });\n          `.trim(),\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\n                  .split(\":\")\n                  .slice(1)\n                  .join(\":\")\n                  .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\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};\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    const sonamuSharedImports = [\n      \"type ListResult\",\n      \"type FilterQuery\",\n      ...builtInTypeImports,\n      \"fetch\",\n      \"type EventHandlers\",\n      \"type SSEStreamOptions\",\n      \"useSSEStream\",\n      \"toFormData\",\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        \"/** biome-ignore-all lint: generated는 무시 */\",\n        \"/** biome-ignore-all assist: generated는 무시 */\",\n        \"\",\n        `import { queryOptions, useQuery, 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"],"names":["inflection","diff","unique","apiParamToTsCode","apiParamTypeToTsType","unwrapPromiseOnce","Sonamu","EntityManager","ApiParamType","assertDefined","Template","BUILT_IN_TYPES","zodTypeToTsTypeDef","Template__services","getTargetAndPath","target","path","render","apis","syncer","apisByModel","Map","api","modelName","replace","has","set","get","push","importKeys","namespaces","typeParamNames","modelApis","functions","streamOptions","paramsWithoutContext","parameters","filter","param","isContext","type","isRefKnex","optional","name","startsWith","apiBaseUrl","config","route","prefix","methodNameStream","options","resourceName","camelize","methodName","methodNameStreamCamelized","eventsTypeDef","events","paramsDefAsObject","length","map","p","join","trim","typeParametersAsTsType","typeParameters","typeParam","typeParamsDef","concat","tp","id","paramsDef","paramNames","returnTypeDef","returnType","clients","includes","formDataAppend","otherParamsAppend","isPrimitive","paramsDefComma","timeout","httpMethod","hasParams","hookName","mutationParamType","mutationParamNames","paramsTypeDef","split","slice","mutationFnCall","entityIds","getAllIds","asyncIdConfigs","entityId","names","getNamesFromId","listApi","capital","find","pluralize","useHookName","listParamsType","builtInTypeImports","Object","keys","typeKey","sonamuSharedImports","bodyParts","body","customHeaders"],"mappings":"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"}
+//#endregion
+export { Template__services };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"services.template.js","names":["importKeys: string[]","namespaces: string[]","typeParamNames: string[]","functions: string[]","paramsWithoutContext","apiBaseUrl","asyncIdConfigs: string[]"],"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\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        // 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\n          functions.push(\n            `\nexport const use${inflection.camelize(hookName)} = ${typeParamsDef}(${paramsDef}${\n              paramsDef ? \", \" : \"\"\n            }options?: { enabled?: boolean }) =>\n  useQuery({\n    ...${methodName}QueryOptions(${paramNames}),\n    ...options\n  });\n          `.trim(),\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\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};\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    const sonamuSharedImports = [\n      \"type ListResult\",\n      \"type FilterQuery\",\n      ...builtInTypeImports,\n      \"fetch\",\n      \"type EventHandlers\",\n      \"type SSEStreamOptions\",\n      \"useSSEStream\",\n      \"toFormData\",\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        \"/* oxlint-disable */\",\n        \"\",\n        `import { queryOptions, useQuery, 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/dist/template/implementations/view_form.template.d.ts

@@ -1,5 +1,5 @@
 import { type EntityNamesRecord } from "../../entity/entity-manager";
-import type { RenderingNode, TemplateOptions } from "../../types/types";
+import { type RenderingNode, type TemplateOptions } from "../../types/types";
 import { Template } from "../template";
 export declare class Template__view_form extends Template {
     constructor();

package/dist/template/implementations/view_form.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view_form.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_form.template.ts"],"names":[],"mappings":"AAEA,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACpF,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAMxE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOhC,mBAAmB,IAAI,MAAM,EAAE,GAAG,IAAI;IAI/C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAI5C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa;;;;;;;;;IAwBvD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM;IAuF1D,mBAAmB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM;IAqC/C,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,WAAW,CAAC;;;;;;CA2VxD"}
+{"version":3,"file":"view_form.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/view_form.template.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAM7E,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB,CAAC,KAAK,EAAE,iBAAiB;;;;IAOhC,mBAAmB,IAAI,MAAM,EAAE,GAAG,IAAI;IAI/C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAI5C,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa;;;;;;;;;IAwBvD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM;IAuF1D,mBAAmB,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,MAAM;IAqC/C,MAAM,CAAC,EAAE,QAAQ,EAAE,EAAE,eAAe,CAAC,WAAW,CAAC;;;;;;CA2VxD"}