sonamu 0.10.12 → 0.10.13

package/src/template/implementations/view_list.template.ts

@@ -13,6 +13,15 @@ import {
 import { type RenderedTemplate } from "../template";
 import { Template } from "../template";
 
+function getConfigEnumId(config: RenderingNode["config"]): string | undefined {
+  if (!config || !("enumId" in config)) {
+    return undefined;
+  }
+  return Object.prototype.toString.call(config.enumId) === "[object String]"
+    ? String(config.enumId)
+    : undefined;
+}
+
 export class Template__view_list extends Template {
   constructor() {
     super("view_list");
@@ -225,12 +234,7 @@ export class Template__view_list extends Template {
     }
   }
 
-  getDefault(columns: RenderingNode[]): {
-    orderBy: string;
-    search: string;
-    hasSearch: boolean;
-    hasOrderBy: boolean;
-  } {
+  getDefault(columns: RenderingNode[]) {
     const def = {
       orderBy: "",
       search: "",
@@ -266,7 +270,9 @@ export class Template__view_list extends Template {
     const idTsType = pkType === "string" || pkType === "uuid" ? "string" : "number";
 
     // 실제 리스트 컬럼
-    const columns = (columnsNode.children as RenderingNode[])
+    const columns = /* SAFETY: Columns 렌더링 노드의 자식은 모두 컬럼 노드다. */ (
+      columnsNode.children as RenderingNode[]
+    )
 
       .toSorted((a, b) => (a.name === "id" ? -1 : b.name === "id" ? 1 : 0))
       .map((col) => {
@@ -299,17 +305,20 @@ export class Template__view_list extends Template {
       });
 
     // 필터 컬럼
-    const filterColumns = (listParamsNode.children as RenderingNode[])
-      .filter(
-        (col) =>
-          col.name !== "id" &&
-          col.name !== "queryMode" &&
-          ["enums", "number-id", "number-fk_id", "string-fk_id"].includes(col.renderType),
+    const filterColumns =
+      /* SAFETY: ListParams 렌더링 노드의 자식은 모두 필터 컬럼 노드다. */ (
+        listParamsNode.children as RenderingNode[]
       )
-      // orderBy가 가장 뒤로 오게 순서 조정
-      .toSorted((a) => {
-        return a.name === "orderBy" ? 1 : -1;
-      });
+        .filter(
+          (col) =>
+            col.name !== "id" &&
+            col.name !== "queryMode" &&
+            ["enums", "number-id", "number-fk_id", "string-fk_id"].includes(col.renderType),
+        )
+        // orderBy가 가장 뒤로 오게 순서 조정
+        .toSorted((a) => {
+          return a.name === "orderBy" ? 1 : -1;
+        });
 
     // 필터 컬럼을 프리 템플릿으로 설정
     const preTemplates: RenderedTemplate["preTemplates"] = [];
@@ -359,13 +368,15 @@ import { ${(() => {
         }
 
         // 필터 enum 수집 (config.enumId 우선, 없으면 getEnumInfoFromColName)
+        // SAFETY: 마지막 Boolean 필터가 null을 제거해 enum 식별자 문자열만 남긴다.
         const filterEnumIds = filterColumns
           .filter(
             (col) => col.renderType === "enums" && col.name !== "search" && col.name !== "orderBy",
           )
           .map((col) => {
-            if (col.config && "enumId" in col.config) {
-              return (col.config as { enumId: string }).enumId;
+            const configEnumId = getConfigEnumId(col.config);
+            if (configEnumId) {
+              return configEnumId;
             }
             try {
               const { id: enumId } = getEnumInfoFromColName(entityId, col.name);
@@ -613,10 +624,7 @@ ${filterColumns
     if (col.renderType === "enums") {
       try {
         // config.enumId가 있으면 우선 사용, 없으면 getEnumInfoFromColName 시도
-        const enumId =
-          col.config && "enumId" in col.config
-            ? (col.config as { enumId: string }).enumId
-            : getEnumInfoFromColName(entityId, col.name).id;
+        const enumId = getConfigEnumId(col.config) ?? getEnumInfoFromColName(entityId, col.name).id;
         return `                  <EnumSelect
                     key={\`${col.name}-\${listParams.${col.name}}\`}
                     enum={${enumId}}

package/src/template/template-manager.ts

@@ -3,8 +3,11 @@ import path from "path";
 import { type TemplateKey } from "../types/types";
 import { globAsync } from "../utils/async-utils";
 import { importMembers } from "../utils/esm-utils";
+import { isFunctionValue } from "../utils/runtime-value";
 import { Template } from "./template";
 
+type TemplateConstructor = new () => Template;
+
 class TemplateManagerClass {
   private templates: Map<TemplateKey | string, Template> = new Map();
   isAutoloaded: boolean = false;
@@ -26,12 +29,8 @@ class TemplateManagerClass {
 
     for (const templateFile of templateFiles) {
       const templates = await importMembers<unknown>(templateFile);
-      if (
-        templates.length === 1 &&
-        typeof templates[0].value === "function" &&
-        templates[0].value.prototype instanceof Template
-      ) {
-        const instance = new (templates[0].value as new () => Template)();
+      if (templates.length === 1 && this.isTemplateClass(templates[0].value)) {
+        const instance = new templates[0].value();
         this.templates.set(instance.key, instance);
       } else {
         throw new Error(
@@ -41,7 +40,10 @@ class TemplateManagerClass {
     }
 
     for (const [key, template] of this.templates) {
-      Template._getTemplatesMap().set(key as TemplateKey, template);
+      Template.getTemplatesMap().set(
+        /* SAFETY: 선행 Zod 종류 분기와 템플릿 입력 계약이 이 값의 타입을 보장한다. */ key as TemplateKey,
+        template,
+      );
     }
 
     this.isAutoloaded = true;
@@ -52,7 +54,7 @@ class TemplateManagerClass {
    */
   async reload(): Promise<void> {
     this.templates.clear();
-    Template._clearTemplates();
+    Template.clearTemplates();
     this.isAutoloaded = false;
     await this.autoload();
   }
@@ -68,7 +70,7 @@ class TemplateManagerClass {
       const templates = await importMembers<unknown>(file);
       for (const { value } of templates) {
         if (this.isTemplateClass(value)) {
-          const instance = new (value as new () => Template)();
+          const instance = new value();
           this.register(instance);
           count++;
         }
@@ -78,8 +80,8 @@ class TemplateManagerClass {
     return count;
   }
 
-  private isTemplateClass(value: unknown): boolean {
-    return typeof value === "function" && value.prototype instanceof Template;
+  private isTemplateClass<Value>(value: Value): value is Value & TemplateConstructor {
+    return isFunctionValue(value) && value.prototype instanceof Template;
   }
 
   // ================================
@@ -92,7 +94,7 @@ class TemplateManagerClass {
   register(template: Template): void {
     this.templates.set(template.key, template);
     // 하위 호환
-    Template._getTemplatesMap().set(template.key, template);
+    Template.getTemplatesMap().set(template.key, template);
   }
 
   /**
@@ -152,7 +154,7 @@ class TemplateManagerClass {
   reset(): void {
     this.templates.clear();
     this.isAutoloaded = false;
-    Template._clearTemplates();
+    Template.clearTemplates();
   }
 
   /**

package/src/template/template-types.ts

@@ -1,16 +1,24 @@
+import { type TemplateKey, type TemplateOptions } from "../types/types";
+
+type TemplateGroupEntry = {
+  [Key in TemplateKey]: {
+    key: Key;
+    getOptions: (baseOptions: Partial<TemplateOptions>) => TemplateOptions[Key];
+  };
+}[TemplateKey];
+
 /**
  * 템플릿 그룹 (관련 템플릿 묶음 실행)
  */
 export type TemplateGroup = {
   name: string;
   description?: string;
-  templates: Array<{
-    key: string;
-    getOptions: (baseOptions: Record<string, unknown>) => Record<string, unknown>;
-  }>;
+  templates: TemplateGroupEntry[];
 };
 
 /**
  * 템플릿 프리셋 (템플릿별 기본 옵션)
  */
-export type TemplatePreset = Record<string, Record<string, unknown>>;
+export type TemplatePreset = Partial<{
+  [Key in TemplateKey]: TemplateOptions[Key];
+}>;

package/src/template/template.ts

@@ -4,6 +4,7 @@ import { type EntityNamesRecord } from "../entity/entity-manager";
 import { type TemplateKey, type TemplateOptions } from "../types/types";
 import { globAsync } from "../utils/async-utils";
 import { importMembers } from "../utils/esm-utils";
+import { isFunctionValue } from "../utils/runtime-value";
 
 export type RenderedTemplate = {
   target: string;
@@ -42,7 +43,7 @@ export abstract class Template {
       const templates = await importMembers<any>(templateFile);
       if (
         templates.length === 1 &&
-        typeof templates[0].value === "function" &&
+        isFunctionValue(templates[0].value) &&
         templates[0].value.prototype instanceof Template
       ) {
         // 클래스의 인스턴스를 생성하여 등록
@@ -80,14 +81,14 @@ export abstract class Template {
   /**
    * 내부용: TemplateManager에서 사용
    */
-  public static _getTemplatesMap(): Map<TemplateKey, Template> {
+  public static getTemplatesMap(): Map<TemplateKey, Template> {
     return Template.templates;
   }
 
   /**
    * 내부용: TemplateManager에서 사용
    */
-  public static _clearTemplates(): void {
+  public static clearTemplates(): void {
     Template.templates.clear();
   }