sonamu 0.7.16 → 0.7.18

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

@@ -0,0 +1,180 @@
+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 { ApiParamType } from "../../types/types.js";
+import { assertDefined } from "../../utils/utils.js";
+import { Template } from "../template.js";
+import { 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 paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);
+                    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).join(", ")} }` : "{}";
+                    functions.push(`
+export function ${methodNameStreamCamelized}(
+  params: ${paramsDef ? `{ ${paramsWithoutContext.map((p)=>`${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(", ")} }` : "{}"},
+  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,
+  options: SSEStreamOptions
+) {
+  return useSSEStream<${eventsTypeDef}>(\`${apiBaseUrl}\`, ${paramsDefAsObject}, 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 isMultiple = api.uploadOptions?.mode === "multiple";
+                    const fileParamName = isMultiple ? "files" : "file";
+                    const fileParamType = isMultiple ? "File[]" : "File";
+                    const formDataAppend = isMultiple ? `${fileParamName}.forEach(f => { formData.append("${fileParamName}", f); });` : `formData.append("${fileParamName}", ${fileParamName});`;
+                    const otherParamsAppend = paramsWithoutContext.map((param)=>`formData.append('${param.name}', String(${param.name}));`).join("\n    ");
+                    const paramsDefComma = paramsDef !== "" ? ", " : "";
+                    functions.push(`
+export async function ${methodName}${typeParamsDef}(
+  ${paramsDef}${paramsDefComma}
+  ${fileParamName}: ${fileParamType},
+  onUploadProgress?: (pe: AxiosProgressEvent) => void
+): Promise<${returnTypeDef}> {
+  const formData = new FormData();
+  ${formDataAppend}
+  ${otherParamsAppend}
+  return fetch({
+    method: 'POST',
+    url: \`${apiBaseUrl}\`,
+    headers: {
+      "Content-Type": "multipart/form-data",
+    },
+    onUploadProgress,
+    data: formData,
+    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+  });
+}
+          `.trim());
+                } 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",
+    url: \`${apiBaseUrl}${hasParams ? `?\${qs.stringify({ ${paramNames} })}` : ""}\`,
+    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+  });
+}
+          `.trim());
+                } else {
+                    const hasParams = paramsWithoutContext.length > 0;
+                    functions.push(`
+export async function ${methodName}${typeParamsDef}(${paramsDef}): Promise<${returnTypeDef}> {
+  return fetch({
+    method: "${api.options.httpMethod}",
+    url: \`${apiBaseUrl}\`,
+    ${hasParams ? `data: { ${paramNames} },` : ""}
+    ${api.options.timeout ? `signal: AbortSignal.timeout(${api.options.timeout}),` : ""}
+  });
+}
+          `.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(`
+export const ${methodName}QueryOptions = ${typeParamsDef}(${paramsDef}) => queryOptions({
+  queryKey: ['${modelName}', '${methodName}'${paramNames ? `, ${paramNames}` : ""}],
+  queryFn: () => ${methodName}(${paramNames})
+});
+          `.trim());
+                    // useQuery hook
+                    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(`
+export const use${hookName}Mutation = ${typeParamsDef}() => useMutation({
+  mutationFn: (params: ${mutationParamType}) => ${methodName}(${mutationParamNames})
+});
+          `.trim());
+                }
+            }
+            namespaces.push(`
+export namespace ${modelName}Service {
+${functions.join("\n\n")}
+}
+      `.trim());
+        }
+        return {
+            ...this.getTargetAndPath(),
+            body: namespaces.join("\n\n"),
+            importKeys: diff(unique(importKeys), [
+                ...typeParamNames,
+                "ListResult"
+            ]),
+            customHeaders: [
+                `import { queryOptions, useQuery, useMutation } from '@tanstack/react-query';`,
+                `import type { AxiosProgressEvent } from 'axios';`,
+                `import qs from 'qs';`,
+                `import { type ListResult, fetch, type EventHandlers, type SSEStreamOptions, useSSEStream } from './sonamu.shared';`
+            ]
+        };
+    }
+}
+
+//# 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 type { TemplateOptions } from \"../../types/types\";\nimport { ApiParamType } from \"../../types/types\";\nimport { assertDefined } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { 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 paramsDef = apiParamToTsCode(paramsWithoutContext, importKeys);\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          const paramsDefAsObject =\n            paramsWithoutContext.length > 0\n              ? `{ ${paramsWithoutContext.map((p) => p.name).join(\", \")} }`\n              : \"{}\";\n\n          functions.push(\n            `\nexport function ${methodNameStreamCamelized}(\n  params: ${paramsDef ? `{ ${paramsWithoutContext.map((p) => `${p.name}: ${apiParamTypeToTsType(p.type, importKeys)}`).join(\", \")} }` : \"{}\"},\n  handlers: EventHandlers<${eventsTypeDef} & { end?: () => void }>,\n  options: SSEStreamOptions\n) {\n  return useSSEStream<${eventsTypeDef}>(\\`${apiBaseUrl}\\`, ${paramsDefAsObject}, 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 isMultiple = api.uploadOptions?.mode === \"multiple\";\n          const fileParamName = isMultiple ? \"files\" : \"file\";\n          const fileParamType = isMultiple ? \"File[]\" : \"File\";\n\n          const formDataAppend = isMultiple\n            ? `${fileParamName}.forEach(f => { formData.append(\"${fileParamName}\", f); });`\n            : `formData.append(\"${fileParamName}\", ${fileParamName});`;\n\n          const otherParamsAppend = paramsWithoutContext\n            .map((param) => `formData.append('${param.name}', String(${param.name}));`)\n            .join(\"\\n    \");\n\n          const paramsDefComma = paramsDef !== \"\" ? \", \" : \"\";\n          functions.push(\n            `\nexport async function ${methodName}${typeParamsDef}(\n  ${paramsDef}${paramsDefComma}\n  ${fileParamName}: ${fileParamType},\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    headers: {\n      \"Content-Type\": \"multipart/form-data\",\n    },\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\n      namespaces.push(\n        `\nexport namespace ${modelName}Service {\n${functions.join(\"\\n\\n\")}\n}\n      `.trim(),\n      );\n    }\n\n    return {\n      ...this.getTargetAndPath(),\n      body: namespaces.join(\"\\n\\n\"),\n      importKeys: diff(unique(importKeys), [...typeParamNames, \"ListResult\"]),\n      customHeaders: [\n        `import { queryOptions, useQuery, useMutation } from '@tanstack/react-query';`,\n        `import type { AxiosProgressEvent } from 'axios';`,\n        `import qs from 'qs';`,\n        `import { type ListResult, fetch, type EventHandlers, type SSEStreamOptions, useSSEStream } from './sonamu.shared';`,\n      ],\n    };\n  }\n}\n"],"names":["inflection","diff","unique","apiParamToTsCode","apiParamTypeToTsType","unwrapPromiseOnce","Sonamu","ApiParamType","assertDefined","Template","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","paramsDef","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","paramNames","returnTypeDef","returnType","clients","includes","isMultiple","uploadOptions","mode","fileParamName","fileParamType","formDataAppend","otherParamsAppend","paramsDefComma","timeout","httpMethod","hasParams","hookName","mutationParamType","mutationParamNames","body","customHeaders"],"mappings":"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"}

package/dist/template/implementations/view_form.template.js

@@ -223,7 +223,7 @@ import { defaultCatch } from '@/services/sonamu.shared';
 // import { useCommonModal } from "@/admin-common/CommonModal";
 
 import { ${names.capital}SaveParams } from '@/services/${names.fs}/${names.fs}.types';
-import { ${names.capital}Service } from '@/services/${names.fs}/${names.fs}.service';
+import { ${names.capital}Service } from '@/services/services.generated';
 import { ${names.capital}SubsetA } from '@/services/sonamu.generated';
 ${unique(columns.filter((col)=>[
                     "number-fk_id",
@@ -337,4 +337,4 @@ export function ${names.capitalPlural}Form({ id, mode }: ${names.capitalPlural}F
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/view_form.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { unique } from \"radashi\";\nimport { z } from \"zod\";\nimport { EntityManager, type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport type { RenderingNode, TemplateKey, TemplateOptions } from \"../../types/types\";\nimport { getEnumInfoFromColName, getRelationPropFromColName } from \"../helpers\";\nimport type { RenderedTemplate } from \"../template\";\nimport { Template } from \"../template\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\n\nexport class Template__view_form extends Template {\n  constructor() {\n    super(\"view_form\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \"web/src/pages/admin\",\n      path: `${names.fsPlural}/form.tsx`,\n    };\n  }\n\n  wrapFC(body: string, label?: string): string {\n    return [\n      `<Form.Field>${label ? `\\n   <label>${label}</label>` : \"\"}`,\n      body,\n      `</Form.Field>`,\n    ].join(\"\\n\");\n  }\n  wrapFG(body: string, label?: string): string {\n    return [`<Form.Group widths=\"equal\">`, this.wrapFC(body, label), `</Form.Group>`].join(\"\\n\");\n  }\n\n  renderColumnImport(entityId: string, col: RenderingNode) {\n    if (col.renderType === \"enums\") {\n      const { id, targetEntityNames } = getEnumInfoFromColName(entityId, col.name);\n      const componentId = `${id}Select`;\n      return `import { ${componentId} } from \"@/components/${targetEntityNames.fs}/${componentId}\";`;\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        const componentId = `${relProp.with}IdAsyncSelect`;\n        return `import { ${componentId} } from \"@/components/${targetNames.fs}/${componentId}\";`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  renderColumn(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n    parent: string = \"\",\n  ): string {\n    let regExpr: string = \"\";\n    regExpr = `{...register(\\`${parent}${col.name}\\`)}`;\n\n    switch (col.renderType) {\n      case \"string-plain\":\n        if (col.zodType instanceof z.ZodString && (col.zodType.maxLength ?? 0) <= 512) {\n          return `<Input placeholder=\"${col.label}\" ${regExpr} />`;\n        } else {\n          return `<TextArea rows={8} placeholder=\"${col.label}\" ${regExpr} />`;\n        }\n      case \"datetime\":\n        return `<Input type=\"datetime-local\" ${regExpr} />`;\n      case \"string-datetime\":\n        return `<SQLDateTimeInput ${regExpr} />`;\n      case \"string-date\":\n        return `<SQLDateInput ${regExpr} />`;\n      case \"number-id\":\n        return `<input type=\"hidden\" ${regExpr} />`;\n      case \"number-plain\":\n        return `<NumberInput placeholder=\"${col.label}\" ${regExpr} />`;\n      case \"boolean\":\n        return `<BooleanToggle ${regExpr} />`;\n      case \"string-image\":\n        return `<ImageUploader multiple={false} ${regExpr} />`;\n      case \"array-images\":\n        return `<ImageUploader multiple={true} ${regExpr} maxSize={5} />`;\n      case \"enums\":\n        try {\n          let enumId: string;\n          if (col.name === \"orderBy\") {\n            enumId = `${names.capital}${inflection.camelize(col.name)}Select`;\n          } else {\n            const { id } = getEnumInfoFromColName(entityId, col.name);\n            enumId = `${id}Select`;\n          }\n          return `<${enumId} ${regExpr} ${\n            col.optional || col.nullable ? \"clearable\" : \"\"\n          } textPrefix=\"\" />`;\n        } catch {\n          return `<>찾을 수 없는 Enum ${col.name}</>`;\n        }\n      case \"number-fk_id\":\n        try {\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          const fkId = `${relProp.with}IdAsyncSelect`;\n          return `<${fkId} {...register('${col.name}')} ${\n            col.optional || col.nullable ? \"clearable\" : \"\"\n          } subset=\"A\" />`;\n        } catch {\n          return `<Input ${regExpr} />`;\n        }\n      case \"array\":\n        return `<>${col.name} array</>`;\n      case \"object\":\n        return `<>${col.name} object</>`;\n      case \"vector\":\n        // vector 타입은 일반적으로 API를 통해 생성되므로 읽기 전용으로 표시\n        return `<div className=\"p-8px text-gray-500\">[Vector: ${col.name}] - 임베딩 데이터는 API를 통해 자동 생성됩니다.</div>`;\n      default:\n        throw new Error(`대응 불가능한 렌더 타입 ${col.renderType} on ${col.name}`);\n    }\n  }\n\n  resolveDefaultValue(columns: RenderingNode[]): object {\n    return columns.reduce(\n      (result, col) => {\n        if (col.optional) {\n          return result;\n        }\n\n        let value: unknown;\n        if (col.nullable === true) {\n          value = null;\n        } else if (col.zodType instanceof z.ZodNumber) {\n          value = 0;\n        } else if (col.zodType instanceof z.ZodEnum) {\n          value = Object.keys(col.zodType.options)[0];\n        } else if (col.zodType instanceof z.ZodBoolean) {\n          value = false;\n        } else if (col.zodType instanceof z.ZodDate) {\n          value = new Date();\n        } else if (col.zodType instanceof z.ZodString) {\n          if (col.renderType === \"string-datetime\") {\n            value = \"now()\";\n          } else {\n            value = \"\";\n          }\n        } else if (col.zodType instanceof z.ZodArray) {\n          value = [];\n        } else if (col.zodType instanceof z.ZodObject) {\n          value = {};\n        }\n\n        result[col.name] = value;\n        return result;\n      },\n      {} as { [key: string]: unknown },\n    );\n  }\n\n  async render({ entityId }: TemplateOptions[\"view_form\"]) {\n    const saveParamsZodType = await getZodTypeById(`${entityId}SaveParams`);\n    const saveParamsNode = zodTypeToRenderingNode(saveParamsZodType);\n\n    const entity = EntityManager.get(entityId);\n    const names = EntityManager.getNamesFromId(entityId);\n    const columns = (saveParamsNode.children as RenderingNode[])\n      .filter((col) => col.name !== \"id\")\n      .map((col) => {\n        const propCandidate = entity.props.find((prop) => prop.name === col.name);\n        col.label = propCandidate?.desc ?? col.label;\n        return col;\n      });\n\n    const defaultValue = this.resolveDefaultValue(columns);\n\n    // 프리 템플릿\n    const preTemplates: RenderedTemplate[\"preTemplates\"] = (columns as RenderingNode[])\n      .filter((col) => {\n        if (col.name === \"id\") {\n          return false;\n        } else if (col.name.endsWith(\"_id\") || col.renderType === \"number-id\") {\n          try {\n            getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n            return true;\n          } catch {\n            return false;\n          }\n        } else if (col.renderType === \"enums\") {\n          try {\n            getEnumInfoFromColName(entityId, col.name);\n            return true;\n          } catch {\n            return false;\n          }\n        }\n        return false;\n      })\n      .map((col) => {\n        let key: TemplateKey;\n        let targetMdId = entityId;\n        let enumId: string | undefined;\n        if (col.renderType === \"enums\") {\n          key = \"view_enums_select\";\n          const { targetEntityNames: targetMDNames, id } = getEnumInfoFromColName(\n            entityId,\n            col.name,\n          );\n          targetMdId = targetMDNames.capital;\n          enumId = id;\n        } else {\n          key = \"view_id_async_select\";\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          targetMdId = relProp.with;\n        }\n\n        return {\n          key: key as TemplateKey,\n          options: {\n            entityId: targetMdId,\n            node: col,\n            enumId,\n          },\n        };\n      })\n      .filter((preTemplate) => {\n        if (preTemplate.key === \"view_id_async_select\") {\n          try {\n            EntityManager.get(preTemplate.options.entityId);\n            return true;\n          } catch {\n            return false;\n          }\n        }\n        return true;\n      });\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport React, { useEffect, useState, Dispatch, SetStateAction, forwardRef, Ref, useImperativeHandle, useCallback } from 'react';\nimport { useSearchParams } from 'react-router-dom';\nimport {\n  Button,\n  Checkbox,\n  Form,\n  Header,\n  Input,\n  Segment,\n  TextArea,\n  Label,\n} from 'semantic-ui-react';\nimport { DateTime } from \"luxon\";\n\nimport { BackLink, LinkInput, NumberInput, BooleanToggle, SQLDateTimeInput, SQLDateInput, useTypeForm, useGoBack, formatDateTime } from \"@sonamu-kit/react-sui\";\nimport { defaultCatch } from '@/services/sonamu.shared';\n// import { ImageUploader } from '@/admin-common/ImageUploader';\n// import { useCommonModal } from \"@/admin-common/CommonModal\";\n\nimport { ${names.capital}SaveParams } from '@/services/${names.fs}/${names.fs}.types';\nimport { ${names.capital}Service } from '@/services/${names.fs}/${names.fs}.service';\nimport { ${names.capital}SubsetA } from '@/services/sonamu.generated';\n${unique(\n  columns\n    .filter((col) => [\"number-fk_id\", \"enums\"].includes(col.renderType))\n    .map((col) => {\n      return this.renderColumnImport(entityId, col);\n    }),\n).join(\"\\n\")}\n\nexport default function ${names.capitalPlural}FormPage() {\n  // 라우팅 searchParams\n  const [searchParams] = useSearchParams();\n  const query = {\n    id: searchParams.get('id') ?? undefined,\n  };\n\n  return <${names.capitalPlural}Form id={query?.id ? Number(query.id) : undefined} />;\n}\ntype ${names.capitalPlural}FormProps = {\n  id?: number;\n  mode?: 'page' | 'modal';\n};\nexport function ${names.capitalPlural}Form({ id, mode }: ${names.capitalPlural}FormProps) {\n  // 편집시 기존 row\n  const [row, setRow] = useState<${names.capital}SubsetA | undefined>();\n\n  // ${names.capital}SaveParams 폼\n  const { form, setForm, register } = useTypeForm(${names.capital}SaveParams, ${JSON.stringify(\n    defaultValue,\n  ).replace(/\"now\\(\\)\"/g, \"DateTime.local().toSQL()!.slice(0, 19)\")});\n\n  // 수정일 때 기존 row 콜\n  useEffect(() => {\n    if (id) {\n      ${names.capital}Service.get${names.capital}('A', id).then((row) => {\n        setRow(row);\n        setForm({\n          ...row,\n          ${columns\n            .filter((col) => col.renderType === \"number-fk_id\")\n            .map((col) => {\n              if (col.nullable) {\n                return `${col.name}: row.${col.name.replace(\"_id\", \"?.id\")} ?? null`;\n              } else {\n                return `${col.name}: row.${col.name.replace(\"_id\", \".id\")}`;\n              }\n            })\n            .join(\",\\n\")}\n        });\n      });\n    }\n  }, [id]);\n\n  // CommonModal\n  // const { doneModal, closeModal } = useCommonModal();\n\n  // 저장\n  const { goBack } = useGoBack();\n  const handleSubmit = useCallback(() => {\n    ${names.capital}Service.save([form]).then(([id]) => {\n      if( mode === 'modal' ) {\n        // doneModal();\n      } else {\n        goBack('/admin/${names.fsPlural}');\n      }\n    }).catch(defaultCatch);\n  }, [ form, mode, id ]);\n\n  // 페이지\n  const PAGE = {\n    title: \\`${entity.title ?? names.capital}\\${id ? \\`#\\${id} 수정\\` : ' 등록'}\\`,\n  }\n\n  return (\n    <div className=\"form\">\n      <Segment padded basic>\n        <Segment padded color=\"grey\">\n          <div className=\"header-row\">\n            <Header>\n              {PAGE.title}\n            </Header>\n            { mode !== 'modal' && <div className=\"buttons\">\n              <BackLink primary size=\"tiny\" to=\"/admin/${\n                names.fsPlural\n              }\" content=\"목록\" icon=\"list\" />\n            </div>}\n          </div>\n          <Form>\n            ${columns\n              .map((col) => {\n                if (col.name === \"created_at\") {\n                  return `{form.id && (${this.wrapFG(\n                    `<div className=\"p-8px\">{formatDateTime(form.${col.name})}</div>`,\n                    \"등록일시\",\n                  )})}`;\n                } else {\n                  return this.wrapFG(\n                    this.renderColumn(entityId, col, names),\n                    (() => {\n                      if (col.label.endsWith(\"Id\")) {\n                        try {\n                          const entity = EntityManager.get(col.label.replace(\"Id\", \"\"));\n                          return entity.title ?? col.label;\n                        } catch {\n                          return col.label;\n                        }\n                      }\n                      return col.label;\n                    })(),\n                  );\n                }\n              })\n              .join(\"\\n\")}\n            <Segment basic textAlign=\"center\">\n              <Button type=\"submit\" primary onClick={handleSubmit} content=\"저장\" icon=\"save\" />\n            </Segment>\n          </Form>\n        </Segment>\n      </Segment>\n    </div>\n  );\n};\n      `.trim(),\n      importKeys: [],\n      preTemplates,\n    };\n  }\n}\n"],"names":["inflection","unique","z","EntityManager","getEnumInfoFromColName","getRelationPropFromColName","Template","getZodTypeById","zodTypeToRenderingNode","Template__view_form","getTargetAndPath","names","target","path","fsPlural","wrapFC","body","label","join","wrapFG","renderColumnImport","entityId","col","renderType","id","targetEntityNames","name","componentId","fs","relProp","replace","targetNames","getNamesFromId","with","Error","renderColumn","parent","regExpr","zodType","ZodString","maxLength","enumId","capital","camelize","optional","nullable","fkId","resolveDefaultValue","columns","reduce","result","value","ZodNumber","ZodEnum","Object","keys","options","ZodBoolean","ZodDate","Date","ZodArray","ZodObject","render","saveParamsZodType","saveParamsNode","entity","get","children","filter","map","propCandidate","props","find","prop","desc","defaultValue","preTemplates","endsWith","key","targetMdId","targetMDNames","node","preTemplate","includes","capitalPlural","JSON","stringify","title","trim","importKeys"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/view_form.template.ts"],"sourcesContent":["import inflection from \"inflection\";\nimport { unique } from \"radashi\";\nimport { z } from \"zod\";\nimport { EntityManager, type EntityNamesRecord } from \"../../entity/entity-manager\";\nimport type { RenderingNode, TemplateKey, TemplateOptions } from \"../../types/types\";\nimport { getEnumInfoFromColName, getRelationPropFromColName } from \"../helpers\";\nimport type { RenderedTemplate } from \"../template\";\nimport { Template } from \"../template\";\nimport { getZodTypeById, zodTypeToRenderingNode } from \"../zod-converter\";\n\nexport class Template__view_form extends Template {\n  constructor() {\n    super(\"view_form\");\n  }\n\n  getTargetAndPath(names: EntityNamesRecord) {\n    return {\n      target: \"web/src/pages/admin\",\n      path: `${names.fsPlural}/form.tsx`,\n    };\n  }\n\n  wrapFC(body: string, label?: string): string {\n    return [\n      `<Form.Field>${label ? `\\n   <label>${label}</label>` : \"\"}`,\n      body,\n      `</Form.Field>`,\n    ].join(\"\\n\");\n  }\n  wrapFG(body: string, label?: string): string {\n    return [`<Form.Group widths=\"equal\">`, this.wrapFC(body, label), `</Form.Group>`].join(\"\\n\");\n  }\n\n  renderColumnImport(entityId: string, col: RenderingNode) {\n    if (col.renderType === \"enums\") {\n      const { id, targetEntityNames } = getEnumInfoFromColName(entityId, col.name);\n      const componentId = `${id}Select`;\n      return `import { ${componentId} } from \"@/components/${targetEntityNames.fs}/${componentId}\";`;\n    } else if (col.renderType === \"number-fk_id\") {\n      try {\n        const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n        const targetNames = EntityManager.getNamesFromId(relProp.with);\n        const componentId = `${relProp.with}IdAsyncSelect`;\n        return `import { ${componentId} } from \"@/components/${targetNames.fs}/${componentId}\";`;\n      } catch {\n        return \"\";\n      }\n    } else {\n      throw new Error(`렌더 불가능한 임포트 ${col.name} ${col.renderType}`);\n    }\n  }\n\n  renderColumn(\n    entityId: string,\n    col: RenderingNode,\n    names: EntityNamesRecord,\n    parent: string = \"\",\n  ): string {\n    let regExpr: string = \"\";\n    regExpr = `{...register(\\`${parent}${col.name}\\`)}`;\n\n    switch (col.renderType) {\n      case \"string-plain\":\n        if (col.zodType instanceof z.ZodString && (col.zodType.maxLength ?? 0) <= 512) {\n          return `<Input placeholder=\"${col.label}\" ${regExpr} />`;\n        } else {\n          return `<TextArea rows={8} placeholder=\"${col.label}\" ${regExpr} />`;\n        }\n      case \"datetime\":\n        return `<Input type=\"datetime-local\" ${regExpr} />`;\n      case \"string-datetime\":\n        return `<SQLDateTimeInput ${regExpr} />`;\n      case \"string-date\":\n        return `<SQLDateInput ${regExpr} />`;\n      case \"number-id\":\n        return `<input type=\"hidden\" ${regExpr} />`;\n      case \"number-plain\":\n        return `<NumberInput placeholder=\"${col.label}\" ${regExpr} />`;\n      case \"boolean\":\n        return `<BooleanToggle ${regExpr} />`;\n      case \"string-image\":\n        return `<ImageUploader multiple={false} ${regExpr} />`;\n      case \"array-images\":\n        return `<ImageUploader multiple={true} ${regExpr} maxSize={5} />`;\n      case \"enums\":\n        try {\n          let enumId: string;\n          if (col.name === \"orderBy\") {\n            enumId = `${names.capital}${inflection.camelize(col.name)}Select`;\n          } else {\n            const { id } = getEnumInfoFromColName(entityId, col.name);\n            enumId = `${id}Select`;\n          }\n          return `<${enumId} ${regExpr} ${\n            col.optional || col.nullable ? \"clearable\" : \"\"\n          } textPrefix=\"\" />`;\n        } catch {\n          return `<>찾을 수 없는 Enum ${col.name}</>`;\n        }\n      case \"number-fk_id\":\n        try {\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          const fkId = `${relProp.with}IdAsyncSelect`;\n          return `<${fkId} {...register('${col.name}')} ${\n            col.optional || col.nullable ? \"clearable\" : \"\"\n          } subset=\"A\" />`;\n        } catch {\n          return `<Input ${regExpr} />`;\n        }\n      case \"array\":\n        return `<>${col.name} array</>`;\n      case \"object\":\n        return `<>${col.name} object</>`;\n      case \"vector\":\n        // vector 타입은 일반적으로 API를 통해 생성되므로 읽기 전용으로 표시\n        return `<div className=\"p-8px text-gray-500\">[Vector: ${col.name}] - 임베딩 데이터는 API를 통해 자동 생성됩니다.</div>`;\n      default:\n        throw new Error(`대응 불가능한 렌더 타입 ${col.renderType} on ${col.name}`);\n    }\n  }\n\n  resolveDefaultValue(columns: RenderingNode[]): object {\n    return columns.reduce(\n      (result, col) => {\n        if (col.optional) {\n          return result;\n        }\n\n        let value: unknown;\n        if (col.nullable === true) {\n          value = null;\n        } else if (col.zodType instanceof z.ZodNumber) {\n          value = 0;\n        } else if (col.zodType instanceof z.ZodEnum) {\n          value = Object.keys(col.zodType.options)[0];\n        } else if (col.zodType instanceof z.ZodBoolean) {\n          value = false;\n        } else if (col.zodType instanceof z.ZodDate) {\n          value = new Date();\n        } else if (col.zodType instanceof z.ZodString) {\n          if (col.renderType === \"string-datetime\") {\n            value = \"now()\";\n          } else {\n            value = \"\";\n          }\n        } else if (col.zodType instanceof z.ZodArray) {\n          value = [];\n        } else if (col.zodType instanceof z.ZodObject) {\n          value = {};\n        }\n\n        result[col.name] = value;\n        return result;\n      },\n      {} as { [key: string]: unknown },\n    );\n  }\n\n  async render({ entityId }: TemplateOptions[\"view_form\"]) {\n    const saveParamsZodType = await getZodTypeById(`${entityId}SaveParams`);\n    const saveParamsNode = zodTypeToRenderingNode(saveParamsZodType);\n\n    const entity = EntityManager.get(entityId);\n    const names = EntityManager.getNamesFromId(entityId);\n    const columns = (saveParamsNode.children as RenderingNode[])\n      .filter((col) => col.name !== \"id\")\n      .map((col) => {\n        const propCandidate = entity.props.find((prop) => prop.name === col.name);\n        col.label = propCandidate?.desc ?? col.label;\n        return col;\n      });\n\n    const defaultValue = this.resolveDefaultValue(columns);\n\n    // 프리 템플릿\n    const preTemplates: RenderedTemplate[\"preTemplates\"] = (columns as RenderingNode[])\n      .filter((col) => {\n        if (col.name === \"id\") {\n          return false;\n        } else if (col.name.endsWith(\"_id\") || col.renderType === \"number-id\") {\n          try {\n            getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n            return true;\n          } catch {\n            return false;\n          }\n        } else if (col.renderType === \"enums\") {\n          try {\n            getEnumInfoFromColName(entityId, col.name);\n            return true;\n          } catch {\n            return false;\n          }\n        }\n        return false;\n      })\n      .map((col) => {\n        let key: TemplateKey;\n        let targetMdId = entityId;\n        let enumId: string | undefined;\n        if (col.renderType === \"enums\") {\n          key = \"view_enums_select\";\n          const { targetEntityNames: targetMDNames, id } = getEnumInfoFromColName(\n            entityId,\n            col.name,\n          );\n          targetMdId = targetMDNames.capital;\n          enumId = id;\n        } else {\n          key = \"view_id_async_select\";\n          const relProp = getRelationPropFromColName(entityId, col.name.replace(\"_id\", \"\"));\n          targetMdId = relProp.with;\n        }\n\n        return {\n          key: key as TemplateKey,\n          options: {\n            entityId: targetMdId,\n            node: col,\n            enumId,\n          },\n        };\n      })\n      .filter((preTemplate) => {\n        if (preTemplate.key === \"view_id_async_select\") {\n          try {\n            EntityManager.get(preTemplate.options.entityId);\n            return true;\n          } catch {\n            return false;\n          }\n        }\n        return true;\n      });\n\n    return {\n      ...this.getTargetAndPath(names),\n      body: `\nimport React, { useEffect, useState, Dispatch, SetStateAction, forwardRef, Ref, useImperativeHandle, useCallback } from 'react';\nimport { useSearchParams } from 'react-router-dom';\nimport {\n  Button,\n  Checkbox,\n  Form,\n  Header,\n  Input,\n  Segment,\n  TextArea,\n  Label,\n} from 'semantic-ui-react';\nimport { DateTime } from \"luxon\";\n\nimport { BackLink, LinkInput, NumberInput, BooleanToggle, SQLDateTimeInput, SQLDateInput, useTypeForm, useGoBack, formatDateTime } from \"@sonamu-kit/react-sui\";\nimport { defaultCatch } from '@/services/sonamu.shared';\n// import { ImageUploader } from '@/admin-common/ImageUploader';\n// import { useCommonModal } from \"@/admin-common/CommonModal\";\n\nimport { ${names.capital}SaveParams } from '@/services/${names.fs}/${names.fs}.types';\nimport { ${names.capital}Service } from '@/services/services.generated';\nimport { ${names.capital}SubsetA } from '@/services/sonamu.generated';\n${unique(\n  columns\n    .filter((col) => [\"number-fk_id\", \"enums\"].includes(col.renderType))\n    .map((col) => {\n      return this.renderColumnImport(entityId, col);\n    }),\n).join(\"\\n\")}\n\nexport default function ${names.capitalPlural}FormPage() {\n  // 라우팅 searchParams\n  const [searchParams] = useSearchParams();\n  const query = {\n    id: searchParams.get('id') ?? undefined,\n  };\n\n  return <${names.capitalPlural}Form id={query?.id ? Number(query.id) : undefined} />;\n}\ntype ${names.capitalPlural}FormProps = {\n  id?: number;\n  mode?: 'page' | 'modal';\n};\nexport function ${names.capitalPlural}Form({ id, mode }: ${names.capitalPlural}FormProps) {\n  // 편집시 기존 row\n  const [row, setRow] = useState<${names.capital}SubsetA | undefined>();\n\n  // ${names.capital}SaveParams 폼\n  const { form, setForm, register } = useTypeForm(${names.capital}SaveParams, ${JSON.stringify(\n    defaultValue,\n  ).replace(/\"now\\(\\)\"/g, \"DateTime.local().toSQL()!.slice(0, 19)\")});\n\n  // 수정일 때 기존 row 콜\n  useEffect(() => {\n    if (id) {\n      ${names.capital}Service.get${names.capital}('A', id).then((row) => {\n        setRow(row);\n        setForm({\n          ...row,\n          ${columns\n            .filter((col) => col.renderType === \"number-fk_id\")\n            .map((col) => {\n              if (col.nullable) {\n                return `${col.name}: row.${col.name.replace(\"_id\", \"?.id\")} ?? null`;\n              } else {\n                return `${col.name}: row.${col.name.replace(\"_id\", \".id\")}`;\n              }\n            })\n            .join(\",\\n\")}\n        });\n      });\n    }\n  }, [id]);\n\n  // CommonModal\n  // const { doneModal, closeModal } = useCommonModal();\n\n  // 저장\n  const { goBack } = useGoBack();\n  const handleSubmit = useCallback(() => {\n    ${names.capital}Service.save([form]).then(([id]) => {\n      if( mode === 'modal' ) {\n        // doneModal();\n      } else {\n        goBack('/admin/${names.fsPlural}');\n      }\n    }).catch(defaultCatch);\n  }, [ form, mode, id ]);\n\n  // 페이지\n  const PAGE = {\n    title: \\`${entity.title ?? names.capital}\\${id ? \\`#\\${id} 수정\\` : ' 등록'}\\`,\n  }\n\n  return (\n    <div className=\"form\">\n      <Segment padded basic>\n        <Segment padded color=\"grey\">\n          <div className=\"header-row\">\n            <Header>\n              {PAGE.title}\n            </Header>\n            { mode !== 'modal' && <div className=\"buttons\">\n              <BackLink primary size=\"tiny\" to=\"/admin/${\n                names.fsPlural\n              }\" content=\"목록\" icon=\"list\" />\n            </div>}\n          </div>\n          <Form>\n            ${columns\n              .map((col) => {\n                if (col.name === \"created_at\") {\n                  return `{form.id && (${this.wrapFG(\n                    `<div className=\"p-8px\">{formatDateTime(form.${col.name})}</div>`,\n                    \"등록일시\",\n                  )})}`;\n                } else {\n                  return this.wrapFG(\n                    this.renderColumn(entityId, col, names),\n                    (() => {\n                      if (col.label.endsWith(\"Id\")) {\n                        try {\n                          const entity = EntityManager.get(col.label.replace(\"Id\", \"\"));\n                          return entity.title ?? col.label;\n                        } catch {\n                          return col.label;\n                        }\n                      }\n                      return col.label;\n                    })(),\n                  );\n                }\n              })\n              .join(\"\\n\")}\n            <Segment basic textAlign=\"center\">\n              <Button type=\"submit\" primary onClick={handleSubmit} content=\"저장\" icon=\"save\" />\n            </Segment>\n          </Form>\n        </Segment>\n      </Segment>\n    </div>\n  );\n};\n      `.trim(),\n      importKeys: [],\n      preTemplates,\n    };\n  }\n}\n"],"names":["inflection","unique","z","EntityManager","getEnumInfoFromColName","getRelationPropFromColName","Template","getZodTypeById","zodTypeToRenderingNode","Template__view_form","getTargetAndPath","names","target","path","fsPlural","wrapFC","body","label","join","wrapFG","renderColumnImport","entityId","col","renderType","id","targetEntityNames","name","componentId","fs","relProp","replace","targetNames","getNamesFromId","with","Error","renderColumn","parent","regExpr","zodType","ZodString","maxLength","enumId","capital","camelize","optional","nullable","fkId","resolveDefaultValue","columns","reduce","result","value","ZodNumber","ZodEnum","Object","keys","options","ZodBoolean","ZodDate","Date","ZodArray","ZodObject","render","saveParamsZodType","saveParamsNode","entity","get","children","filter","map","propCandidate","props","find","prop","desc","defaultValue","preTemplates","endsWith","key","targetMdId","targetMDNames","node","preTemplate","includes","capitalPlural","JSON","stringify","title","trim","importKeys"],"mappings":"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"}

package/dist/template/implementations/view_id_async_select.template.js

@@ -35,7 +35,7 @@ export class Template__view_id_async_select extends Template {
 import React, { useState, useEffect, SyntheticEvent } from "react";
 import { DropdownProps, DropdownItemProps, DropdownOnSearchChangeData, Dropdown } from "semantic-ui-react";
 import { ${names.capital}SubsetKey, ${names.capital}SubsetMapping } from "@/services/sonamu.generated";
-import { ${names.capital}Service } from "@/services/${names.fs}/${names.fs}.service";
+import { ${names.capital}Service } from "@/services/services.generated";
 import { ${names.capital}ListParams } from "@/services/${names.fs}/${names.fs}.types";
 
 export function ${names.capital}IdAsyncSelect<T extends ${names.capital}SubsetKey>(
@@ -102,4 +102,4 @@ export function ${names.capital}IdAsyncSelect<T extends ${names.capital}SubsetKe
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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