sonamu 0.0.42 → 0.1.2

package/src/templates/generated.template.ts

@@ -6,9 +6,9 @@ import {
   isTimestampProp,
   TemplateOptions,
 } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
-import { SMD } from "../smd/smd";
-import { SMDPropNode, SubsetQuery } from "../types/types";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
+import { Entity } from "../entity/entity";
+import { EntityPropNode, SubsetQuery } from "../types/types";
 import { propNodeToZodTypeDef } from "../api/code-converters";
 import { Template } from "./base-template";
 
@@ -17,21 +17,25 @@ export class Template__generated extends Template {
     super("generated");
   }
 
-  getTargetAndPath(names: SMDNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord) {
     return {
       target: "api/src/application",
       path: `${names.fs}/${names.fs}.generated.ts`,
     };
   }
 
-  render({ smdId }: TemplateOptions["generated"]) {
-    const names = SMDManager.getNamesFromId(smdId);
-    const smd = SMDManager.get(smdId);
+  render({ entityId }: TemplateOptions["generated"]) {
+    const entity = EntityManager.get(entityId);
 
     const typeSource = [
-      this.getBaseSchemaTypeSource(smd),
-      this.getBaseListParamsTypeSource(smd),
-      this.getSubsetTypeSource(smd),
+      this.getEnumsTypeSource(entity),
+      this.getBaseSchemaTypeSource(entity),
+      ...(entity.parentId === undefined
+        ? [
+            this.getBaseListParamsTypeSource(entity),
+            this.getSubsetTypeSource(entity),
+          ]
+        : []),
     ].reduce(
       (result, ts) => {
         if (ts === null) {
@@ -48,49 +52,80 @@ export class Template__generated extends Template {
       }
     );
 
-    const fieldExprs = smd
-      .getFieldExprs()
-      .map((fieldExpr) => `"${fieldExpr}"`)
-      .join(" | ");
-    const fieldExprsLine = `export type ${smd.id}FieldExpr = ${
-      fieldExprs.length > 0 ? fieldExprs : "string"
-    }`;
+    // targetAndPath
+    const names = EntityManager.getNamesFromId(entityId);
+    const targetAndPath = this.getTargetAndPath(names);
+
+    // import
+    const sonamuImports = [
+      "zArrayable",
+      ...(entity.props.find(
+        (p) => isTimestampProp(p) || isDateProp(p) || isDateTimeProp(p)
+      )
+        ? ["SQLDateTimeString"]
+        : []),
+    ];
 
     return {
-      ...this.getTargetAndPath(names),
-      body: [...typeSource!.lines, fieldExprsLine, "/* END Server-side Only */"]
+      ...targetAndPath,
+      body: [...typeSource!.lines, "/* END Server-side Only */"]
         .join("\n")
         .trim(),
       importKeys: typeSource?.importKeys ?? [],
       customHeaders: [
         `import { z } from 'zod';`,
-        smd.props.length > 0
-          ? `import { zArrayable${
-              smd.props.find(
-                (p) => isTimestampProp(p) || isDateProp(p) || isDateTimeProp(p)
-              )
-                ? ", SQLDateTimeString"
-                : ""
-            } } from "sonamu";`
+        entity.props.length > 0
+          ? `import { ${sonamuImports.join(",")} } from "sonamu";`
           : "",
       ],
     };
   }
 
+  getEnumsTypeSource(entity: Entity): {
+    lines: string[];
+    importKeys: string[];
+  } {
+    const childrenIds = EntityManager.getChildrenIds(entity.id);
+    const entities = [
+      entity,
+      ...childrenIds.map((id) => EntityManager.get(id)),
+    ];
+
+    return {
+      lines: [
+        "// Enums",
+        ...entities
+          .map((entity) =>
+            Object.entries(entity.enumLabels).map(([enumId, enumLabel]) => [
+              `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(
+                (el) => `"${el}"`
+              )}]).describe("${enumId}");`,
+              `export type ${enumId} = z.infer<typeof ${enumId}>`,
+              `export const ${enumId}Label = ${JSON.stringify(enumLabel)}`,
+            ])
+          )
+          .flat()
+          .flat(),
+        "",
+      ],
+      importKeys: [],
+    };
+  }
+
   getBaseSchemaTypeSource(
-    smd: SMD,
+    entity: Entity,
     depth: number = 0,
     importKeys: string[] = []
   ): {
     lines: string[];
     importKeys: string[];
   } {
-    const childrenIds = SMDManager.getChildrenIds(smd.id);
+    const childrenIds = EntityManager.getChildrenIds(entity.id);
 
-    const schemaName = `${smd.names.module}BaseSchema`;
-    const propNode: SMDPropNode = {
+    const schemaName = `${entity.names.module}BaseSchema`;
+    const propNode: EntityPropNode = {
       nodeType: "object",
-      children: smd.props.map((prop) => {
+      children: entity.props.map((prop) => {
         return {
           nodeType: "plain",
           prop,
@@ -105,7 +140,7 @@ export class Template__generated extends Template {
       `export type ${schemaName} = z.infer<typeof ${schemaName}>`,
       ...childrenIds
         .map((childId) => {
-          const child = SMDManager.get(childId);
+          const child = EntityManager.get(childId);
           const { lines } = this.getBaseSchemaTypeSource(
             child,
             depth + 1,
@@ -122,23 +157,23 @@ export class Template__generated extends Template {
     };
   }
 
-  getBaseListParamsTypeSource(smd: SMD): {
+  getBaseListParamsTypeSource(entity: Entity): {
     lines: string[];
     importKeys: string[];
   } {
     // Prop 없는 MD인 경우 생성 제외
-    if (smd.props.length === 0) {
+    if (entity.props.length === 0) {
       return {
         lines: [],
         importKeys: [],
       };
     }
 
-    const schemaName = `${smd.names.module}BaseListParams`;
+    const schemaName = `${entity.names.module}BaseListParams`;
 
-    const filterProps = smd.props.filter((prop) => prop.toFilter === true);
+    const filterProps = entity.props.filter((prop) => prop.toFilter === true);
 
-    const propNodes: SMDPropNode[] = filterProps.map((prop) => {
+    const propNodes: EntityPropNode[] = filterProps.map((prop) => {
       return {
         nodeType: "plain" as const,
         prop,
@@ -146,7 +181,7 @@ export class Template__generated extends Template {
       };
     });
 
-    const importKeys: string[] = [`${smd.id}SearchField`, `${smd.id}OrderBy`];
+    const importKeys: string[] = [];
     const filterBody = propNodes
       .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))
       .join("\n");
@@ -155,9 +190,9 @@ export class Template__generated extends Template {
 z.object({
   num: z.number().int().nonnegative(),
   page: z.number().int().min(1),
-  search: ${smd.id}SearchField,
+  search: ${entity.id}SearchField,
   keyword: z.string(),
-  orderBy: ${smd.id}OrderBy,
+  orderBy: ${entity.id}OrderBy,
   withoutCount: z.boolean(),
   id: zArrayable(z.number().int().positive()),${filterBody}
 }).partial();
@@ -174,19 +209,19 @@ z.object({
     };
   }
 
-  getSubsetTypeSource(smd: SMD): {
+  getSubsetTypeSource(entity: Entity): {
     lines: string[];
     importKeys: string[];
   } | null {
-    if (Object.keys(smd.subsets).length == 0) {
+    if (Object.keys(entity.subsets).length == 0) {
       return null;
     }
 
-    const subsetKeys = Object.keys(smd.subsets);
+    const subsetKeys = Object.keys(entity.subsets);
 
     const subsetQueryObject = subsetKeys.reduce(
       (r, subsetKey) => {
-        const subsetQuery = smd.getSubsetQuery(subsetKey);
+        const subsetQuery = entity.getSubsetQuery(subsetKey);
         r[subsetKey] = subsetQuery;
         return r;
       },
@@ -201,17 +236,17 @@ z.object({
       ...subsetKeys
         .map((subsetKey) => {
           // 서브셋에서 FieldExpr[] 가져옴
-          const fieldExprs = smd.subsets[subsetKey];
+          const fieldExprs = entity.subsets[subsetKey];
 
-          // FieldExpr[]로 MDPropNode[] 가져옴
-          const propNodes = smd.fieldExprsToPropNodes(fieldExprs);
-          const schemaName = `${smd.names.module}Subset${subsetKey}`;
-          const propNode: SMDPropNode = {
+          // FieldExpr[]로 EntityPropNode[] 가져옴
+          const propNodes = entity.fieldExprsToPropNodes(fieldExprs);
+          const schemaName = `${entity.names.module}Subset${subsetKey}`;
+          const propNode: EntityPropNode = {
             nodeType: "object",
             children: propNodes,
           };
 
-          // MDPropNode[]로 ZodTypeDef(string)을 가져옴
+          // EntityPropNode[]로 ZodTypeDef(string)을 가져옴
           const body = propNodeToZodTypeDef(propNode, importKeys);
 
           return [
@@ -222,20 +257,21 @@ z.object({
         })
         .flat(),
       "",
-      `export type ${smd.names.module}SubsetMapping = {`,
+      `export type ${entity.names.module}SubsetMapping = {`,
       ...subsetKeys.map(
-        (subsetKey) => `  ${subsetKey}: ${smd.names.module}Subset${subsetKey};`
+        (subsetKey) =>
+          `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`
       ),
       "}",
-      `export const ${smd.names.module}SubsetKey = z.enum([${subsetKeys
+      `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys
         .map((k) => `"${k}"`)
         .join(",")}]);`,
-      `export type ${smd.names.module}SubsetKey = z.infer<typeof ${smd.names.module}SubsetKey>`,
+      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>`,
       "",
       "/* BEGIN- Server-side Only */",
       `import { SubsetQuery } from "sonamu";`,
-      `export const ${camelize(smd.id, true)}SubsetQueries:{ [key in ${
-        smd.names.module
+      `export const ${camelize(entity.id, true)}SubsetQueries:{ [key in ${
+        entity.names.module
       }SubsetKey]: SubsetQuery} = ${JSON.stringify(subsetQueryObject)}`,
       "",
     ];

package/src/templates/generated_http.template.ts

@@ -1,7 +1,7 @@
 import qs from "qs";
 import { z } from "zod";
 import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { getZodObjectFromApi } from "../api/code-converters";
 import { ExtendedApi } from "../api/decorators";
 import { Template } from "./base-template";
@@ -14,15 +14,15 @@ export class Template__generated_http extends Template {
     super("generated_http");
   }
 
-  getTargetAndPath(names: SMDNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord) {
     return {
       target: "api/src/application",
       path: `${names.fs}/${names.fs}.generated.http`,
     };
   }
 
-  render({ smdId }: TemplateOptions["generated"], apis: ExtendedApi[]) {
-    const names = SMDManager.getNamesFromId(smdId);
+  render({ entityId }: TemplateOptions["generated"], apis: ExtendedApi[]) {
+    const names = EntityManager.getNamesFromId(entityId);
     const references = Sonamu.syncer.types;
 
     const lines = apis.map((api) => {

package/src/templates/init_types.template.ts

@@ -1,5 +1,5 @@
 import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 
 export class Template__init_types extends Template {
@@ -7,29 +7,29 @@ export class Template__init_types extends Template {
     super("init_types");
   }
 
-  getTargetAndPath(names: SMDNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord) {
     return {
       target: "api/src/application",
       path: `${names.fs}/${names.fs}.types.ts`,
     };
   }
 
-  render({ smdId }: TemplateOptions["init_types"]) {
-    const names = SMDManager.getNamesFromId(smdId);
+  render({ entityId }: TemplateOptions["init_types"]) {
+    const names = EntityManager.getNamesFromId(entityId);
 
     return {
       ...this.getTargetAndPath(names),
       body: `
 import { z } from "zod";
-import { ${smdId}BaseSchema, ${smdId}BaseListParams } from "./${names.fs}.generated";
+import { ${entityId}BaseSchema, ${entityId}BaseListParams } from "./${names.fs}.generated";
 
-// ${smdId} - ListParams
-export const ${smdId}ListParams = ${smdId}BaseListParams;
-export type ${smdId}ListParams = z.infer<typeof ${smdId}ListParams>;
+// ${entityId} - ListParams
+export const ${entityId}ListParams = ${entityId}BaseListParams;
+export type ${entityId}ListParams = z.infer<typeof ${entityId}ListParams>;
 
-// ${smdId} - SaveParams
-export const ${smdId}SaveParams = ${smdId}BaseSchema.partial({ id: true });
-export type ${smdId}SaveParams = z.infer<typeof ${smdId}SaveParams>;
+// ${entityId} - SaveParams
+export const ${entityId}SaveParams = ${entityId}BaseSchema.partial({ id: true });
+export type ${entityId}SaveParams = z.infer<typeof ${entityId}SaveParams>;
 
       `.trim(),
       importKeys: [],

package/src/templates/model.template.ts

@@ -1,5 +1,5 @@
 import { RenderingNode, TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 import { Template__view_list } from "./view_list.template";
 
@@ -8,7 +8,7 @@ export class Template__model extends Template {
     super("model");
   }
 
-  getTargetAndPath(names: SMDNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord) {
     return {
       target: "api/src/application",
       path: `${names.fs}/${names.fs}.model.ts`,
@@ -16,12 +16,12 @@ export class Template__model extends Template {
   }
 
   render(
-    { smdId }: TemplateOptions["model"],
+    { entityId }: TemplateOptions["model"],
     _columnsNode: RenderingNode,
     listParamsNode: RenderingNode
   ) {
-    const names = SMDManager.getNamesFromId(smdId);
-    const smd = SMDManager.get(smdId);
+    const names = EntityManager.getNamesFromId(entityId);
+    const entity = EntityManager.get(entityId);
 
     const vlTpl = new Template__view_list();
     const def = vlTpl.getDefault(listParamsNode.children!);
@@ -31,23 +31,23 @@ export class Template__model extends Template {
       body: `
 import { BaseModelClass, ListResult, asArray, NotFoundException, BadRequestException, api } from 'sonamu';
 import {
-  ${smdId}SubsetKey,
-  ${smdId}SubsetMapping,
+  ${entityId}SubsetKey,
+  ${entityId}SubsetMapping,
   ${names.camel}SubsetQueries,
 } from "./${names.fs}.generated";
-import { ${smdId}ListParams, ${smdId}SaveParams } from "./${names.fs}.types";
+import { ${entityId}ListParams, ${entityId}SaveParams } from "./${names.fs}.types";
 
 /*
-  ${smdId} Model
+  ${entityId} Model
 */
-class ${smdId}ModelClass extends BaseModelClass {
-  modelName = "${smdId}";
+class ${entityId}ModelClass extends BaseModelClass {
+  modelName = "${entityId}";
 
-  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${smdId}" })
-  async findById<T extends ${smdId}SubsetKey>(
+  @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${entityId}" })
+  async findById<T extends ${entityId}SubsetKey>(
     subset: T,
     id: number
-  ): Promise<${smdId}SubsetMapping[T]> {
+  ): Promise<${entityId}SubsetMapping[T]> {
     const { rows } = await this.findMany(subset, {
       id,
       num: 1,
@@ -60,10 +60,10 @@ class ${smdId}ModelClass extends BaseModelClass {
     return rows[0];
   }
 
-  async findOne<T extends ${smdId}SubsetKey>(
+  async findOne<T extends ${entityId}SubsetKey>(
     subset: T,
-    listParams: ${smdId}ListParams
-  ): Promise<${smdId}SubsetMapping[T] | null> {
+    listParams: ${entityId}ListParams
+  ): Promise<${entityId}SubsetMapping[T] | null> {
     const { rows } = await this.findMany(subset, {
       ...listParams,
       num: 1,
@@ -74,10 +74,10 @@ class ${smdId}ModelClass extends BaseModelClass {
   }
 
   @api({ httpMethod: "GET", clients: ["axios", "swr"], resourceName: "${names.capitalPlural}" })
-  async findMany<T extends ${smdId}SubsetKey>(
+  async findMany<T extends ${entityId}SubsetKey>(
     subset: T,
-    params: ${smdId}ListParams = {}
-  ): Promise<ListResult<${smdId}SubsetMapping[T]>> {
+    params: ${entityId}ListParams = {}
+  ): Promise<ListResult<${entityId}SubsetMapping[T]>> {
     // params with defaults
     params = {
       num: 24,
@@ -95,15 +95,15 @@ class ${smdId}ModelClass extends BaseModelClass {
       build: ({ qb }) => {
         // id
         if (params.id) {
-          qb.whereIn("${smd.table}.id", asArray(params.id));
+          qb.whereIn("${entity.table}.id", asArray(params.id));
         }
 
         // search-keyword
         if (params.search && params.keyword && params.keyword.length > 0) {
           if (params.search === "id") {
-            qb.where("${smd.table}.id", params.keyword);
+            qb.where("${entity.table}.id", params.keyword);
           // } else if (params.search === "field") {
-          //   qb.where("${smd.table}.field", "like", \`%\${params.keyword}%\`);
+          //   qb.where("${entity.table}.field", "like", \`%\${params.keyword}%\`);
           } else {
             throw new BadRequestException(
               \`구현되지 않은 검색 필드 \${params.search}\`
@@ -115,7 +115,7 @@ class ${smdId}ModelClass extends BaseModelClass {
         if (params.orderBy) {
           // default orderBy
           const [orderByField, orderByDirec] = params.orderBy.split("-");
-          qb.orderBy("${smd.table}." + orderByField, orderByDirec);
+          qb.orderBy("${entity.table}." + orderByField, orderByDirec);
         }
 
         return qb;
@@ -131,19 +131,19 @@ class ${smdId}ModelClass extends BaseModelClass {
 
   @api({ httpMethod: "POST" })
   async save(
-    saveParamsArray: ${smdId}SaveParams[]
+    saveParamsArray: ${entityId}SaveParams[]
   ): Promise<number[]> {
     const wdb = this.getDB("w");
     const ub = this.getUpsertBuilder();
 
     // register
     saveParamsArray.map((saveParams) => {
-      ub.register("${smd.table}", saveParams);
+      ub.register("${entity.table}", saveParams);
     });
 
     // transaction
     return wdb.transaction(async (trx) => {
-      const ids = await ub.upsert(trx, "${smd.table}");
+      const ids = await ub.upsert(trx, "${entity.table}");
 
       return ids;
     });
@@ -155,14 +155,14 @@ class ${smdId}ModelClass extends BaseModelClass {
 
     // transaction
     await wdb.transaction(async (trx) => {
-      return trx("${smd.table}").whereIn("${smd.table}.id", ids).delete();
+      return trx("${entity.table}").whereIn("${entity.table}.id", ids).delete();
     });
 
     return ids.length;
   }
 }
 
-export const ${smdId}Model = new ${smdId}ModelClass();
+export const ${entityId}Model = new ${entityId}ModelClass();
       `.trim(),
       importKeys: [],
     };

package/src/templates/model_test.template.ts

@@ -1,5 +1,5 @@
 import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 
 export class Template__model_test extends Template {
@@ -7,15 +7,15 @@ export class Template__model_test extends Template {
     super("model_test");
   }
 
-  getTargetAndPath(names: SMDNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord) {
     return {
       target: "api/src/application",
       path: `${names.fs}/${names.fs}.model.test.ts`,
     };
   }
 
-  render({ smdId }: TemplateOptions["model_test"]) {
-    const names = SMDManager.getNamesFromId(smdId);
+  render({ entityId }: TemplateOptions["model_test"]) {
+    const names = EntityManager.getNamesFromId(entityId);
 
     return {
       ...this.getTargetAndPath(names),
@@ -24,7 +24,7 @@ import { describe, test, expect } from "vitest";
 import { bootstrap } from '../../testing/bootstrap';
 
 bootstrap([]);
-describe.skip("${smdId}ModelTest", () => {
+describe.skip("${entityId}ModelTest", () => {
   test("Query", async () => {
     expect(true).toBe(true);
   });

package/src/templates/service.template.ts

@@ -1,7 +1,7 @@
 import { camelize } from "inflection";
 import { groupBy, sortBy, difference, uniq } from "lodash";
 import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { ApiParamType, ApiParam } from "../types/types";
 import {
   apiParamTypeToTsType,
@@ -17,15 +17,15 @@ export class Template__service extends Template {
     super("service");
   }
 
-  getTargetAndPath(names: SMDNamesRecord) {
+  getTargetAndPath(names: EntityNamesRecord) {
     return {
       target: ":target/src/services",
       path: `${names.fs}/${names.fs}.service.ts`,
     };
   }
 
-  render({ smdId }: TemplateOptions["service"], apis: ExtendedApi[]) {
-    const names = SMDManager.getNamesFromId(smdId);
+  render({ entityId }: TemplateOptions["service"], apis: ExtendedApi[]) {
+    const names = EntityManager.getNamesFromId(entityId);
 
     // 서비스 TypeSource
     const { lines, importKeys } = this.getTypeSource(apis);

package/src/templates/view_enums_buttonset.template.ts

@@ -1,5 +1,5 @@
 import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 
 export class Template__view_enums_buttonset extends Template {
@@ -7,15 +7,15 @@ export class Template__view_enums_buttonset extends Template {
     super("view_enums_buttonset");
   }
 
-  getTargetAndPath(names: SMDNamesRecord, componentId: string) {
+  getTargetAndPath(names: EntityNamesRecord, componentId: string) {
     return {
       target: "web/src/components",
       path: `${names.fs}/${componentId}ButtonSet.tsx`,
     };
   }
 
-  render({ smdId, enumId }: TemplateOptions["view_enums_buttonset"]) {
-    const names = SMDManager.getNamesFromId(smdId);
+  render({ entityId, enumId }: TemplateOptions["view_enums_buttonset"]) {
+    const names = EntityManager.getNamesFromId(entityId);
 
     return {
       ...this.getTargetAndPath(names, enumId),
@@ -24,7 +24,7 @@ export class Template__view_enums_buttonset extends Template {
 view_enums_buttonset
 ${JSON.stringify({
   key: this.key,
-  options: smdId,
+  options: entityId,
 })}
 */
       `.trim(),

package/src/templates/view_enums_dropdown.template.ts

@@ -1,5 +1,5 @@
 import { TemplateOptions } from "../types/types";
-import { SMDManager, SMDNamesRecord } from "../smd/smd-manager";
+import { EntityManager, EntityNamesRecord } from "../entity/entity-manager";
 import { Template } from "./base-template";
 
 export class Template__view_enums_dropdown extends Template {
@@ -7,7 +7,7 @@ export class Template__view_enums_dropdown extends Template {
     super("view_enums_dropdown");
   }
 
-  getTargetAndPath(names: SMDNamesRecord, enumId: string) {
+  getTargetAndPath(names: EntityNamesRecord, enumId: string) {
     return {
       target: "web/src/components",
       path: `${names.fs}/${enumId}Dropdown.tsx`,
@@ -15,11 +15,11 @@ export class Template__view_enums_dropdown extends Template {
   }
 
   render({
-    smdId,
+    entityId,
     enumId,
     idConstant,
   }: TemplateOptions["view_enums_dropdown"]) {
-    const names = SMDManager.getNamesFromId(smdId);
+    const names = EntityManager.getNamesFromId(entityId);
     const label = getLabel(idConstant);
 
     return {