sonamu 0.5.7 → 0.7.0

package/src/entity/entity.ts

@@ -1,30 +1,33 @@
-import _ from "lodash";
-import { EntityManager as EntityManager } from "./entity-manager";
+import assert from "assert";
+import { writeFile } from "fs/promises";
+import inflection from "inflection";
+import path from "path";
+import { group, unique } from "radashi";
+import { z } from "zod";
+import { Sonamu } from "../api/sonamu";
 import {
-  EntityProp,
-  RelationProp,
-  isRelationProp,
-  SubsetQuery,
-  isVirtualProp,
+  type EntityIndex,
+  type EntityJson,
+  type EntityProp,
+  type EntityPropNode,
+  type EntitySubsetRow,
   isBelongsToOneRelationProp,
-  isOneToOneRelationProp,
+  isEnumProp,
   isHasManyRelationProp,
   isManyToManyRelationProp,
-  EntityPropNode,
-  isEnumProp,
-  StringProp,
-  EntityIndex,
-  EntityJson,
-  EntitySubsetRow,
+  isOneToOneRelationProp,
+  isRelationProp,
+  isVirtualProp,
+  type RelationProp,
+  type StringProp,
+  type SubsetQuery,
 } from "../types/types";
-import inflection from "inflection";
-import path from "path";
-import { writeFile } from "fs/promises";
-import { z } from "zod";
-import { Sonamu } from "../api/sonamu";
-import prettier from "prettier";
-import { nonNullable } from "../utils/utils";
+import { importMembers } from "../utils/esm-utils";
+import { formatCode } from "../utils/formatter";
 import { exists } from "../utils/fs-utils";
+import { runtimePath } from "../utils/path-utils";
+import { assertDefined, nonNullable } from "../utils/utils";
+import { EntityManager } from "./entity-manager";
 
 export class Entity {
   id: string;
@@ -51,7 +54,7 @@ export class Entity {
     [name: string]: z.ZodTypeAny;
   } = {};
   enums: {
-    [enumId: string]: z.ZodEnum<any>;
+    [enumId: string]: z.ZodEnum<Readonly<Record<string, string>>>;
   } = {};
   enumLabels: {
     [enumId: string]: {
@@ -59,16 +62,7 @@ export class Entity {
     };
   } = {};
 
-  constructor({
-    id,
-    parentId,
-    table,
-    title,
-    props,
-    indexes,
-    subsets,
-    enums,
-  }: EntityJson) {
+  constructor({ id, parentId, table, title, props, indexes, subsets, enums }: EntityJson) {
     // id
     this.id = id;
     this.parentId = parentId;
@@ -85,22 +79,16 @@ export class Entity {
         }
         return prop;
       });
-      this.propsDict = props.reduce((result, prop) => {
-        return {
-          ...result,
-          [prop.name]: prop,
-        };
-      }, {});
+      this.propsDict = Object.fromEntries(
+        props.map((prop) => {
+          return [prop.name, prop];
+        }),
+      );
 
       // relations
-      this.relations = props
-        .filter((prop) => isRelationProp(prop))
-        .reduce((result, prop) => {
-          return {
-            ...result,
-            [prop.name]: prop,
-          };
-        }, {});
+      this.relations = Object.fromEntries(
+        props.filter((prop) => isRelationProp(prop)).map((prop) => [prop.name, prop]),
+      );
     } else {
       this.props = [];
       this.propsDict = {};
@@ -117,25 +105,180 @@ export class Entity {
     this.enumLabels = enums ?? {};
     this.enums = Object.fromEntries(
       Object.entries(this.enumLabels).map(([key, enumLabel]) => {
-        return [
-          key,
-          z.enum(
-            Object.keys(enumLabel) as unknown as readonly [string, ...string[]]
-          ),
-        ];
-      })
+        return [key, z.enum(Object.keys(enumLabel) as unknown as readonly [string, ...string[]])];
+      }),
     );
 
     // names
     this.names = {
-      parentFs: inflection
-        .dasherize(inflection.underscore(parentId ?? id))
-        .toLowerCase(),
+      parentFs: inflection.dasherize(inflection.underscore(parentId ?? id)).toLowerCase(),
       fs: inflection.dasherize(inflection.underscore(id)).toLowerCase(),
       module: id,
     };
   }
 
+  /*
+    subset을 Puri 코드로 변환
+  */
+  getPuriSubsetQuery(subsetKey: string): string {
+    const subset = this.subsets[subsetKey];
+    const subsetQuery = this.resolveSubsetQuery("", subset);
+
+    const lines: string[] = [];
+
+    // from
+    lines.push(`return qbWrapper`);
+    lines.push(`.from("${this.table}")`);
+
+    // join
+    for (const join of subsetQuery.joins) {
+      const joinMethod = join.join === "inner" ? "join" : "leftJoin";
+
+      if ("custom" in join) {
+        // custom join clause는 raw 사용
+        lines.push(
+          `.${joinMethod}({ ${join.as}: "${join.table}" }, qbWrapper.knex.raw(\`${join.custom}\`))`,
+        );
+      } else {
+        lines.push(`.${joinMethod}({ ${join.as}: "${join.table}" }, "${join.from}", "${join.to}")`);
+      }
+    }
+
+    // select
+    const selectObj: Record<string, string> = {};
+    for (const selectItem of subsetQuery.select) {
+      // "users.id" 또는 "users.id as user__id" 형태
+      const match = selectItem.match(/^(.+?)(?: as (.+))?$/);
+      if (match) {
+        const [, column, alias] = match;
+        const key = alias ?? assertDefined(column.split(".").pop());
+        selectObj[key] = `"${column.trim()}"`;
+      }
+    }
+
+    lines.push(`.select({`);
+    Object.entries(selectObj).forEach(([key, value]) => {
+      lines.push(`${key}: ${value},`);
+    });
+    lines.push(`});`);
+
+    return lines.join("\n");
+  }
+
+  getPuriLoaderQuery(subsetKey: string): string {
+    const subset = this.subsets[subsetKey];
+    const { loaders } = this.resolveSubsetQuery("", subset);
+
+    const lines: string[] = [`[`];
+
+    const parseSelect = (select: string, table: string) => {
+      const tablePrefix = `${table}.`;
+      if (select.startsWith(tablePrefix)) {
+        return `${select.replace(tablePrefix, "")}: "${select}"`;
+      }
+
+      if (select.includes(" as ")) {
+        const [column, alias] = select.split(" as ");
+        return `${alias}: "${column}"`;
+      }
+      return `${select}: "${select}"`;
+    };
+
+    // 재귀적으로 loader 생성하는 헬퍼 함수
+    const generateLoaderCode = (loaders: SubsetQuery["loaders"]): string[] => {
+      const loaderLines: string[] = [];
+
+      for (const loader of loaders) {
+        const { toTable, toCol, through } = loader.manyJoin;
+        loaderLines.push(
+          "{",
+          `as: "${loader.as}",`,
+          `refId: "${loader.manyJoin.idField}",`,
+          `qb: (qbWrapper: PuriWrapper<DatabaseSchemaExtend>, fromIds: number[]) => {`,
+        );
+
+        if (through === undefined) {
+          // HasMany
+          loaderLines.push(
+            //
+            "return qbWrapper",
+            `.from("${toTable}")`,
+          );
+
+          loader.oneJoins.forEach((join: SubsetQuery["joins"][number]) => {
+            const joinType = join.join === "inner" ? "join" : "leftJoin";
+            if ("custom" in join) {
+              // FIXME: 검증 필요
+              loaderLines.push(
+                `.${joinType}({ ${join.as}: "${join.table}" }, (j) => {`,
+                `j.on(Puri.rawString("${join.custom}"));`,
+                "})",
+              );
+            } else {
+              loaderLines.push(
+                `.${joinType}({ ${join.as}: "${join.table}" }, "${join.from}", "${join.to}")`,
+              );
+            }
+          });
+
+          loaderLines.push(
+            `.whereIn("${toTable}.${toCol}", fromIds)`,
+            `.select({`,
+            `${loader.select.map((select: string) => parseSelect(select, toTable)).join(",")},`,
+            `refId: "${toTable}.${toCol}",`,
+            `});`,
+          );
+        } else {
+          // ManyToMany
+          loaderLines.push(
+            "return qbWrapper",
+            `.from("${through.table}")`,
+            `.join("${toTable}", "${through.table}.${through.toCol}", "${toTable}.${toCol}")`,
+          );
+
+          loader.oneJoins.forEach((join: SubsetQuery["joins"][number]) => {
+            const joinType = join.join === "inner" ? "join" : "leftJoin";
+            if ("custom" in join) {
+              // FIXME: 검증 필요
+              loaderLines.push(
+                `.${joinType}({ ${join.as}: "${join.table}" }, (j) => {`,
+                `j.on(Puri.rawString("${join.custom}"));`,
+                "})",
+              );
+            } else {
+              loaderLines.push(
+                `.${joinType}({ ${join.as}: "${join.table}" }, "${join.from}", "${join.to}")`,
+              );
+            }
+          });
+          loaderLines.push(
+            `.whereIn("${through.table}.${through.fromCol}", fromIds)`,
+            `.select({`,
+            `${loader.select.map((select: string) => parseSelect(select, toTable)).join(",")},`,
+            `refId: "${through.table}.${through.fromCol}",`,
+            `});`,
+          );
+        }
+
+        loaderLines.push(`},`);
+
+        // 중첩 loaders 처리
+        if (loader.loaders && loader.loaders.length > 0) {
+          loaderLines.push("loaders: [", ...generateLoaderCode(loader.loaders), "],");
+        }
+
+        loaderLines.push("},");
+      }
+
+      return loaderLines;
+    };
+
+    lines.push(...generateLoaderCode(loaders));
+    lines.push(`]`);
+
+    return lines.join("\n");
+  }
+
   /*
     subset SELECT/JOIN/LOADER 결과 리턴
   */
@@ -151,13 +294,13 @@ export class Entity {
   resolveSubsetQuery(
     prefix: string,
     fields: string[],
-    isAlreadyOuterJoined: boolean = false
+    isAlreadyOuterJoined: boolean = false,
   ): SubsetQuery {
     // prefix 치환 (prefix는 ToOneRelation이 복수로 붙은 경우 모두 __로 변경됨)
     prefix = prefix.replace(/\./g, "__");
 
     // 서브셋을 1뎁스만 분리하여 그룹핑
-    const subsetGroup = _.groupBy(fields, (field) => {
+    const subsetGroup = group(fields, (field) => {
       if (field.includes(".")) {
         const [rel] = field.split(".");
         return rel;
@@ -169,27 +312,21 @@ export class Entity {
     const result = Object.keys(subsetGroup).reduce(
       (r, groupKey) => {
         const fields = subsetGroup[groupKey];
+        assert(fields !== undefined, "fields is undefined");
+
         // 현재 테이블 필드셋은 select, virtual에 추가하고 리턴
         if (groupKey === "") {
-          const realFields = fields.filter(
-            (field) => !isVirtualProp(this.propsDict[field])
-          );
-          const virtualFields = fields.filter((field) =>
-            isVirtualProp(this.propsDict[field])
-          );
+          const realFields = fields.filter((field) => !isVirtualProp(this.propsDict[field]));
+          const virtualFields = fields.filter((field) => isVirtualProp(this.propsDict[field]));
 
           if (prefix === "") {
             // 현재 테이블인 경우
-            r.select = r.select.concat(
-              realFields.map((field) => `${this.table}.${field}`)
-            );
+            r.select = r.select.concat(realFields.map((field) => `${this.table}.${field}`));
             r.virtual = r.virtual.concat(virtualFields);
           } else {
             // 넘어온 테이블인 경우
             r.select = r.select.concat(
-              realFields.map(
-                (field) => `${prefix}.${field} as ${prefix}__${field}`
-              )
+              realFields.map((field) => `${prefix}.${field} as ${prefix}__${field}`),
             );
           }
 
@@ -202,23 +339,16 @@ export class Entity {
         }
         const relEntity = EntityManager.get(relation.with);
 
-        if (
-          isOneToOneRelationProp(relation) ||
-          isBelongsToOneRelationProp(relation)
-        ) {
+        if (isOneToOneRelationProp(relation) || isBelongsToOneRelationProp(relation)) {
           // -One Relation: JOIN 으로 처리
-          const relFields = fields.map((field) =>
-            field.split(".").slice(1).join(".")
-          );
+          const relFields = fields.map((field) => field.split(".").slice(1).join("."));
 
           // -One Relation에서 id 필드만 참조하는 경우 릴레이션 넘기지 않고 리턴
           if (relFields.length === 1 && relFields[0] === "id") {
             if (prefix === "") {
               r.select = r.select.concat(`${this.table}.${groupKey}_id`);
             } else {
-              r.select = r.select.concat(
-                `${prefix}.${groupKey}_id as ${prefix}__${groupKey}_id`
-              );
+              r.select = r.select.concat(`${prefix}.${groupKey}_id as ${prefix}__${groupKey}_id`);
             }
             return r;
           }
@@ -230,10 +360,7 @@ export class Entity {
             }
 
             if (isOneToOneRelationProp(relation)) {
-              if (
-                relation.hasJoinColumn === true &&
-                (relation.nullable ?? false) === false
-              ) {
+              if (relation.hasJoinColumn === true && (relation.nullable ?? false) === false) {
                 return "inner";
               } else {
                 return "outer";
@@ -247,32 +374,37 @@ export class Entity {
             }
           })();
           const relSubsetQuery = relEntity.resolveSubsetQuery(
-            `${prefix !== "" ? prefix + "." : ""}${groupKey}`,
+            `${prefix !== "" ? `${prefix}.` : ""}${groupKey}`,
             relFields,
-            innerOrOuter === "outer"
+            innerOrOuter === "outer",
           );
           r.select = r.select.concat(relSubsetQuery.select);
           r.virtual = r.virtual.concat(relSubsetQuery.virtual);
 
-          const joinAs = prefix === "" ? groupKey : prefix + "__" + groupKey;
+          const joinAs = prefix === "" ? groupKey : `${prefix}__${groupKey}`;
           const fromTable = prefix === "" ? this.table : prefix;
 
-          let joinClause;
+          let joinClause:
+            | {
+                from: string;
+                to: string;
+              }
+            | {
+                custom: string;
+              };
           if (relation.customJoinClause) {
             joinClause = {
               custom: relation.customJoinClause,
             };
           } else {
-            let from, to;
+            let from: string, to: string;
             if (isOneToOneRelationProp(relation)) {
               if (relation.hasJoinColumn) {
                 from = `${fromTable}.${relation.name}_id`;
                 to = `${joinAs}.id`;
               } else {
                 from = `${fromTable}.id`;
-                to = `${joinAs}.${inflection.underscore(
-                  this.names.fs.replace(/\-/g, "_")
-                )}_id`;
+                to = `${joinAs}.${inflection.underscore(this.names.fs.replace(/-/g, "_"))}_id`;
               }
             } else {
               from = `${fromTable}.${relation.name}_id`;
@@ -309,14 +441,9 @@ export class Entity {
           }
 
           r.joins = r.joins.concat(relSubsetQuery.joins);
-        } else if (
-          isHasManyRelationProp(relation) ||
-          isManyToManyRelationProp(relation)
-        ) {
+        } else if (isHasManyRelationProp(relation) || isManyToManyRelationProp(relation)) {
           // -Many Relation: Loader 로 처리
-          const relFields = fields.map((field) =>
-            field.split(".").slice(1).join(".")
-          );
+          const relFields = fields.map((field) => field.split(".").slice(1).join("."));
           const relSubsetQuery = relEntity.resolveSubsetQuery("", relFields);
 
           let manyJoin: SubsetQuery["loaders"][number]["manyJoin"];
@@ -363,7 +490,7 @@ export class Entity {
         virtual: [],
         joins: [],
         loaders: [],
-      } as SubsetQuery
+      } as SubsetQuery,
     );
     return result;
   }
@@ -371,13 +498,10 @@ export class Entity {
   /*
     FieldExpr[] 을 EntityPropNode[] 로 변환
   */
-  fieldExprsToPropNodes(
-    fieldExprs: string[],
-    entity: Entity = this
-  ): EntityPropNode[] {
+  fieldExprsToPropNodes(fieldExprs: string[], entity: Entity = this): EntityPropNode[] {
     const groups = fieldExprs.reduce(
       (result, fieldExpr) => {
-        let key, value, elseExpr;
+        let key: string, value: string, elseExpr: string[];
         if (fieldExpr.includes(".")) {
           [key, ...elseExpr] = fieldExpr.split(".");
           value = elseExpr.join(".");
@@ -391,91 +515,85 @@ export class Entity {
       },
       {} as {
         [k: string]: string[];
-      }
+      },
     );
 
-    return Object.keys(groups)
-      .map((key) => {
-        const group = groups[key];
-
-        // 일반 prop 처리
-        if (key === "") {
-          return group.map((propName) => {
-            // uuid 개별 처리
-            if (propName === "uuid") {
-              return {
-                nodeType: "plain" as const,
-                prop: {
-                  type: "string",
-                  name: "uuid",
-                  length: 128,
-                } as StringProp,
-                children: [],
-              };
-            }
-
-            const prop = entity.props.find((p) => p.name === propName);
-            if (prop === undefined) {
-              console.log({ propName, groups });
-              throw new Error(`${entity.id} -- 잘못된 FieldExpr ${propName}`);
-            }
-            return {
-              nodeType: "plain" as const,
-              prop,
-              children: [],
-            };
-          });
-        }
-
-        // relation prop 처리
-        const prop = entity.propsDict[key];
-        if (!isRelationProp(prop)) {
-          throw new Error(`잘못된 FieldExpr ${key}.${group[0]}`);
-        }
-        const relEntity = EntityManager.get(prop.with);
+    return Object.keys(groups).flatMap((key) => {
+      const group = groups[key];
 
-        // relation -One 에 id 필드 하나인 경우
-        if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)) {
-          if (group.length == 1 && (group[0] === "id" || group[0] == "id?")) {
-            // id 하나만 있는지 체크해서, 하나만 있으면 상위 prop으로 id를 리턴
-            const idProp = relEntity.propsDict.id;
+      // 일반 prop 처리
+      if (key === "") {
+        return group.map((propName) => {
+          // uuid 개별 처리
+          if (propName === "uuid") {
             return {
               nodeType: "plain" as const,
               prop: {
-                ...idProp,
-                name: key + "_id",
-                nullable: prop.nullable,
-              },
+                type: "string",
+                name: "uuid",
+                length: 128,
+              } as StringProp,
               children: [],
-            };
+            } as EntityPropNode;
           }
+
+          const prop = entity.props.find((p) => p.name === propName);
+          if (prop === undefined) {
+            console.log({ propName, groups });
+            throw new Error(`${entity.id} -- 잘못된 FieldExpr ${propName}`);
+          }
+          return {
+            nodeType: "plain" as const,
+            prop,
+            children: [],
+          };
+        });
+      }
+
+      // relation prop 처리
+      const prop = entity.propsDict[key];
+      if (!isRelationProp(prop)) {
+        throw new Error(`잘못된 FieldExpr ${key}.${group[0]}`);
+      }
+      const relEntity = EntityManager.get(prop.with);
+
+      // relation -One 에 id 필드 하나인 경우
+      if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)) {
+        if (group.length === 1 && (group[0] === "id" || group[0] === "id?")) {
+          // id 하나만 있는지 체크해서, 하나만 있으면 상위 prop으로 id를 리턴
+          const idProp = relEntity.propsDict.id;
+          return {
+            nodeType: "plain" as const,
+            prop: {
+              ...idProp,
+              name: `${key}_id`,
+              nullable: prop.nullable,
+            },
+            children: [],
+          };
         }
+      }
 
-        // -One 그외의 경우 object로 리턴
-        // -Many의 경우 array로 리턴
-        // Recursive 로 뎁스 처리
-        const children = this.fieldExprsToPropNodes(group, relEntity);
-        const nodeType =
-          isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)
-            ? ("object" as const)
-            : ("array" as const);
+      // -One 그외의 경우 object로 리턴
+      // -Many의 경우 array로 리턴
+      // Recursive 로 뎁스 처리
+      const children = this.fieldExprsToPropNodes(group, relEntity);
+      const nodeType =
+        isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)
+          ? ("object" as const)
+          : ("array" as const);
 
-        return {
-          prop,
-          children,
-          nodeType,
-        };
-      })
-      .flat();
+      return {
+        prop,
+        children,
+        nodeType,
+      };
+    });
   }
 
-  getFieldExprs(
-    prefix = "",
-    maxDepth: number = 3,
-    froms: string[] = []
-  ): string[] {
+  getFieldExprs(prefix = "", maxDepth: number = 3, froms: string[] = []): string[] {
     return this.props
-      .map((prop) => {
+      .flatMap((prop) => {
         const propName = [prefix, prop.name].filter((v) => v !== "").join(".");
         if (propName === prefix) {
           return null;
@@ -490,14 +608,10 @@ export class Entity {
           }
           // 정방향 relation인 경우 recursive 콜
           const relMd = EntityManager.get(prop.with);
-          return relMd.getFieldExprs(propName, maxDepth - 1, [
-            ...froms,
-            this.id,
-          ]);
+          return relMd.getFieldExprs(propName, maxDepth - 1, [...froms, this.id]);
         }
         return propName;
       })
-      .flat()
       .filter((f) => f !== null) as string[];
   }
 
@@ -528,40 +642,35 @@ export class Entity {
     // subset
     if (Object.keys(this.subsets).length > 0) {
       EntityManager.setModulePath(`${this.id}SubsetKey`, `sonamu.generated`);
-      EntityManager.setModulePath(
-        `${this.id}SubsetMapping`,
-        `sonamu.generated`
-      );
-      Object.keys(this.subsets).map((subsetKey) => {
+      EntityManager.setModulePath(`${this.id}SubsetMapping`, `sonamu.generated`);
+      for (const subsetKey of Object.keys(this.subsets)) {
         EntityManager.setModulePath(
           `${this.id}Subset${subsetKey.toUpperCase()}`,
-          `sonamu.generated`
+          `sonamu.generated`,
         );
-      });
+      }
     }
 
     // enums
-    Object.keys(this.enumLabels).map((enumId) => {
+    for (const enumId of Object.keys(this.enumLabels)) {
       EntityManager.setModulePath(enumId, `sonamu.generated`);
-    });
+    }
 
     // types
     const typesModulePath = `${basePath}/${this.names.parentFs}.types`;
-    const typesFileDistPath = path.join(
+    const typesFilePath = path.join(
       Sonamu.apiRootPath,
-      `dist/application/${typesModulePath}.js`
+      runtimePath(`dist/application/${typesModulePath}.js`),
     );
 
-    if (await exists(typesFileDistPath)) {
-      const importPath = path.relative(__dirname, typesFileDistPath);
-      const t = await import(importPath);
-      this.types = Object.keys(t).reduce((result, key) => {
-        EntityManager.setModulePath(key, typesModulePath);
-        return {
-          ...result,
-          [key]: t[key],
-        };
-      }, {});
+    if (await exists(typesFilePath)) {
+      const importedMembers = await importMembers<z.ZodTypeAny>(typesFilePath);
+      this.types = Object.fromEntries(
+        importedMembers.map(({ name, value }) => {
+          EntityManager.setModulePath(name, typesModulePath);
+          return [name, value];
+        }),
+      ) as { [name: string]: z.ZodTypeAny };
     }
   }
 
@@ -592,25 +701,17 @@ export class Entity {
     const subsetRows = this.getSubsetRows();
     this.subsets = Object.fromEntries(
       Object.entries(this.subsets).map(([subsetKey]) => {
-        return [
-          subsetKey,
-          this.subsetRowsToSubsetFields(subsetRows, subsetKey),
-        ];
-      })
+        return [subsetKey, this.subsetRowsToSubsetFields(subsetRows, subsetKey)];
+      }),
     );
 
     // save
     const jsonPath = path.join(
       Sonamu.apiRootPath,
-      `src/application/${this.names.parentFs}/${this.names.fs}.entity.json`
+      `src/application/${this.names.parentFs}/${this.names.fs}.entity.json`,
     );
     const json = this.toJson();
-    await writeFile(
-      jsonPath,
-      await prettier.format(JSON.stringify(json), {
-        parser: "json",
-      })
-    );
+    await writeFile(jsonPath, formatCode(JSON.stringify(json), "json", jsonPath));
 
     // reload
     await EntityManager.register(json);
@@ -618,7 +719,7 @@ export class Entity {
 
   getSubsetRows(
     _subsets?: { [key: string]: string[] },
-    prefixes: string[] = []
+    prefixes: string[] = [],
   ): EntitySubsetRow[] {
     if (prefixes.length > 10) {
       return [];
@@ -626,20 +727,15 @@ export class Entity {
 
     const subsets = _subsets ?? this.subsets;
     const subsetKeys = Object.keys(subsets);
-    const allFields = _.uniq(subsetKeys.map((key) => subsets[key]).flat());
+    const allFields = unique(subsetKeys.flatMap((key) => subsets[key]));
 
     return this.props.map((prop) => {
       if (
         prop.type === "relation" &&
-        allFields.find((f) =>
-          f.startsWith([...prefixes, prop.name].join(".") + ".")
-        )
+        allFields.find((f) => f.startsWith(`${[...prefixes, prop.name].join(".")}.`))
       ) {
         const relEntity = EntityManager.get(prop.with);
-        const children = relEntity.getSubsetRows(subsets, [
-          ...prefixes,
-          `${prop.name}`,
-        ]);
+        const children = relEntity.getSubsetRows(subsets, [...prefixes, `${prop.name}`]);
 
         return {
           field: prop.name,
@@ -649,11 +745,8 @@ export class Entity {
           isOpen: children.length > 0,
           has: Object.fromEntries(
             subsetKeys.map((subsetKey) => {
-              return [
-                subsetKey,
-                children.every((child) => child.has[subsetKey] === true),
-              ];
-            })
+              return [subsetKey, children.every((child) => child.has[subsetKey] === true)];
+            }),
           ),
         };
       }
@@ -668,19 +761,16 @@ export class Entity {
             const subsetFields = subsets[subsetKey];
             const has = subsetFields.some((f) => {
               const field = [...prefixes, prop.name].join(".");
-              return f === field || f.startsWith(field + ".");
+              return f === field || f.startsWith(`${field}.`);
             });
             return [subsetKey, has];
-          })
+          }),
         ),
       };
     });
   }
 
-  subsetRowsToSubsetFields(
-    subsetRows: EntitySubsetRow[],
-    subsetKey: string
-  ): string[] {
+  subsetRowsToSubsetFields(subsetRows: EntitySubsetRow[], subsetKey: string): string[] {
     return subsetRows
       .map((subsetRow) => {
         if (subsetRow.children.length > 0) {
@@ -722,9 +812,7 @@ export class Entity {
         propName,
       });
 
-      const prop = EntityManager.get(entityId).props.find(
-        (p) => p.name === propName
-      );
+      const prop = EntityManager.get(entityId).props.find((p) => p.name === propName);
       if (!prop) {
         throw new Error(`${entityId}의 잘못된 서브셋키 ${subsetField}`);
       }
@@ -761,7 +849,7 @@ export class Entity {
                     ...a,
                     propName: newProp.name,
                   }
-                : a
+                : a,
             );
             // 분석한 필드를 다시 서브셋 필드로 복구
             return modified.map((a) => a.propName).join(".");
@@ -799,11 +887,7 @@ export class Entity {
         const modifiedSubsetFields = subset
           .map((subsetField) => {
             const analyzed = relEntity.analyzeSubsetField(subsetField);
-            if (
-              analyzed.find(
-                (a) => a.propName === oldName && a.entityId === this.id
-              )
-            ) {
+            if (analyzed.find((a) => a.propName === oldName && a.entityId === this.id)) {
               return null;
             } else {
               return subsetField;
@@ -819,9 +903,9 @@ export class Entity {
     }
 
     // 현재 엔티티의 인덱스에서 제외
-    EntityManager.get(this.id).indexes.map((index) => {
+    for (const index of EntityManager.get(this.id).indexes) {
       index.columns = index.columns.filter((col) => col !== oldName);
-    });
+    }
 
     // 프롭 삭제
     this.props.splice(at, 1);
@@ -839,9 +923,7 @@ export class Entity {
 
     // 서브셋 필드를 내려가면서 마지막으로 relation된 엔티티를 찾음
     const lastEntityId = arr.reduce((entityId, field) => {
-      const relProp = EntityManager.get(entityId).props.find(
-        (p) => p.name === field
-      );
+      const relProp = EntityManager.get(entityId).props.find((p) => p.name === field);
       if (!relProp || relProp.type !== "relation") {
         console.debug({ arr, thisId: this.id, entityId, field });
         throw new Error(`잘못된 서브셋키 ${subsetField}`);