sonamu 0.2.38 → 0.2.40

package/dist/entity/entity.js

@@ -1,697 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Entity = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const entity_manager_1 = require("./entity-manager");
-const types_1 = require("../types/types");
-const inflection_1 = __importDefault(require("inflection"));
-const path_1 = __importDefault(require("path"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const zod_1 = require("zod");
-const sonamu_1 = require("../api/sonamu");
-const prettier_1 = __importDefault(require("prettier"));
-const utils_1 = require("../utils/utils");
-class Entity {
-    constructor({ id, parentId, table, title, props, indexes, subsets, enums, }) {
-        this.types = {};
-        this.enums = {};
-        this.enumLabels = {};
-        // id
-        this.id = id;
-        this.parentId = parentId;
-        this.title = title !== null && title !== void 0 ? title : this.id;
-        this.table = table !== null && table !== void 0 ? table : inflection_1.default.underscore(inflection_1.default.pluralize(id));
-        // props
-        if (props) {
-            this.props = props.map((prop) => {
-                if ((0, types_1.isEnumProp)(prop)) {
-                    if (prop.id.includes("$Model")) {
-                        prop.id = prop.id.replace("$Model", id);
-                    }
-                }
-                return prop;
-            });
-            this.propsDict = props.reduce((result, prop) => {
-                return Object.assign(Object.assign({}, result), { [prop.name]: prop });
-            }, {});
-            // relations
-            this.relations = props
-                .filter((prop) => (0, types_1.isRelationProp)(prop))
-                .reduce((result, prop) => {
-                return Object.assign(Object.assign({}, result), { [prop.name]: prop });
-            }, {});
-        }
-        else {
-            this.props = [];
-            this.propsDict = {};
-            this.relations = {};
-        }
-        // indexes
-        this.indexes = indexes !== null && indexes !== void 0 ? indexes : [];
-        // subsets
-        this.subsets = subsets !== null && subsets !== void 0 ? subsets : {};
-        // enums
-        this.enumLabels = enums !== null && enums !== void 0 ? enums : {};
-        this.enums = Object.fromEntries(Object.entries(this.enumLabels).map(([key, enumLabel]) => {
-            return [
-                key,
-                zod_1.z.enum(Object.keys(enumLabel)),
-            ];
-        }));
-        // names
-        this.names = {
-            parentFs: inflection_1.default
-                .dasherize(inflection_1.default.underscore(parentId !== null && parentId !== void 0 ? parentId : id))
-                .toLowerCase(),
-            fs: inflection_1.default.dasherize(inflection_1.default.underscore(id)).toLowerCase(),
-            module: id,
-        };
-        this.registerModulePaths();
-        this.registerTableSpecs();
-    }
-    /*
-      subset SELECT/JOIN/LOADER 결과 리턴
-    */
-    getSubsetQuery(subsetKey) {
-        const subset = this.subsets[subsetKey];
-        const result = this.resolveSubsetQuery("", subset);
-        return result;
-    }
-    /*
-     */
-    resolveSubsetQuery(prefix, fields, isAlreadyOuterJoined = false) {
-        // prefix 치환 (prefix는 ToOneRelation이 복수로 붙은 경우 모두 __로 변경됨)
-        prefix = prefix.replace(/\./g, "__");
-        // 서브셋을 1뎁스만 분리하여 그룹핑
-        const subsetGroup = lodash_1.default.groupBy(fields, (field) => {
-            if (field.includes(".")) {
-                const [rel] = field.split(".");
-                return rel;
-            }
-            else {
-                return "";
-            }
-        });
-        const result = Object.keys(subsetGroup).reduce((r, groupKey) => {
-            var _a;
-            const fields = subsetGroup[groupKey];
-            // 현재 테이블 필드셋은 select, virtual에 추가하고 리턴
-            if (groupKey === "") {
-                const realFields = fields.filter((field) => !(0, types_1.isVirtualProp)(this.propsDict[field]));
-                const virtualFields = fields.filter((field) => (0, types_1.isVirtualProp)(this.propsDict[field]));
-                if (prefix === "") {
-                    // 현재 테이블인 경우
-                    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}`));
-                }
-                return r;
-            }
-            const relation = this.relations[groupKey];
-            if (relation === undefined) {
-                throw new Error(`존재하지 않는 relation 참조 ${groupKey}`);
-            }
-            const relEntity = entity_manager_1.EntityManager.get(relation.with);
-            if ((0, types_1.isOneToOneRelationProp)(relation) ||
-                (0, types_1.isBelongsToOneRelationProp)(relation)) {
-                // -One Relation: 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`);
-                    }
-                    return r;
-                }
-                // innerOrOuter
-                const innerOrOuter = (() => {
-                    var _a;
-                    if (isAlreadyOuterJoined) {
-                        return "outer";
-                    }
-                    if ((0, types_1.isOneToOneRelationProp)(relation)) {
-                        if (relation.hasJoinColumn === true &&
-                            ((_a = relation.nullable) !== null && _a !== void 0 ? _a : false) === false) {
-                            return "inner";
-                        }
-                        else {
-                            return "outer";
-                        }
-                    }
-                    else {
-                        if (relation.nullable) {
-                            return "outer";
-                        }
-                        else {
-                            return "inner";
-                        }
-                    }
-                })();
-                const relSubsetQuery = relEntity.resolveSubsetQuery(`${prefix !== "" ? prefix + "." : ""}${groupKey}`, relFields, innerOrOuter === "outer");
-                r.select = r.select.concat(relSubsetQuery.select);
-                r.virtual = r.virtual.concat(relSubsetQuery.virtual);
-                const joinAs = prefix === "" ? groupKey : prefix + "__" + groupKey;
-                const fromTable = prefix === "" ? this.table : prefix;
-                let joinClause;
-                if (relation.customJoinClause) {
-                    joinClause = {
-                        custom: relation.customJoinClause,
-                    };
-                }
-                else {
-                    let from, to;
-                    if ((0, types_1.isOneToOneRelationProp)(relation)) {
-                        if (relation.hasJoinColumn) {
-                            from = `${fromTable}.${relation.name}_id`;
-                            to = `${joinAs}.id`;
-                        }
-                        else {
-                            from = `${fromTable}.id`;
-                            to = `${joinAs}.${inflection_1.default.underscore(this.names.fs.replace(/\-/g, "_"))}_id`;
-                        }
-                    }
-                    else {
-                        from = `${fromTable}.${relation.name}_id`;
-                        to = `${joinAs}.id`;
-                    }
-                    joinClause = {
-                        from,
-                        to,
-                    };
-                }
-                r.joins.push(Object.assign({ as: joinAs, join: innerOrOuter, table: relEntity.table }, joinClause));
-                // BelongsToOne 밑에 HasMany가 붙은 경우
-                if (relSubsetQuery.loaders.length > 0) {
-                    const convertedLoaders = relSubsetQuery.loaders.map((loader) => {
-                        const newAs = [groupKey, loader.as].join("__");
-                        return {
-                            as: newAs,
-                            table: loader.table,
-                            manyJoin: loader.manyJoin,
-                            oneJoins: loader.oneJoins,
-                            select: loader.select,
-                            loaders: loader.loaders,
-                        };
-                    });
-                    r.loaders = [...r.loaders, ...convertedLoaders];
-                }
-                r.joins = r.joins.concat(relSubsetQuery.joins);
-            }
-            else if ((0, types_1.isHasManyRelationProp)(relation) ||
-                (0, types_1.isManyToManyRelationProp)(relation)) {
-                // -Many Relation: Loader 로 처리
-                const relFields = fields.map((field) => field.split(".").slice(1).join("."));
-                const relSubsetQuery = relEntity.resolveSubsetQuery("", relFields);
-                let manyJoin;
-                if ((0, types_1.isHasManyRelationProp)(relation)) {
-                    const fromCol = (_a = relation === null || relation === void 0 ? void 0 : relation.fromColumn) !== null && _a !== void 0 ? _a : "id";
-                    manyJoin = {
-                        fromTable: this.table,
-                        fromCol,
-                        idField: prefix === "" ? `${fromCol}` : `${prefix}__${fromCol}`,
-                        toTable: relEntity.table,
-                        toCol: relation.joinColumn,
-                    };
-                }
-                else if ((0, types_1.isManyToManyRelationProp)(relation)) {
-                    const [table1, table2] = relation.joinTable.split("__");
-                    const throughTables = (() => {
-                        // 동일 테이블 릴레이션인 경우
-                        if (this.table === relEntity.table) {
-                            if (table1 === this.table) {
-                                return {
-                                    fromCol: `${inflection_1.default.singularize(table1)}_id`,
-                                    toCol: `${inflection_1.default.singularize(table2)}_id`,
-                                };
-                            }
-                            else {
-                                return {
-                                    fromCol: `${inflection_1.default.singularize(table2)}_id`,
-                                    toCol: `${inflection_1.default.singularize(table1)}_id`,
-                                };
-                            }
-                        }
-                        else {
-                            // 서로 다른 테이블인 경우 릴레이션 테이블 유지
-                            return {
-                                fromCol: `${inflection_1.default.singularize(this.table)}_id`,
-                                toCol: `${inflection_1.default.singularize(relEntity.table)}_id`,
-                            };
-                        }
-                    })();
-                    manyJoin = {
-                        fromTable: this.table,
-                        fromCol: "id",
-                        idField: prefix === "" ? `id` : `${prefix}__id`,
-                        through: Object.assign({ table: relation.joinTable }, throughTables),
-                        toTable: relEntity.table,
-                        toCol: "id",
-                    };
-                }
-                else {
-                    throw new Error();
-                }
-                r.loaders.push({
-                    as: groupKey,
-                    table: relEntity.table,
-                    manyJoin,
-                    oneJoins: relSubsetQuery.joins,
-                    select: relSubsetQuery.select,
-                    loaders: relSubsetQuery.loaders,
-                });
-            }
-            return r;
-        }, {
-            select: [],
-            virtual: [],
-            joins: [],
-            loaders: [],
-        });
-        return result;
-    }
-    /*
-      FieldExpr[] 을 EntityPropNode[] 로 변환
-    */
-    fieldExprsToPropNodes(fieldExprs, entity = this) {
-        const groups = fieldExprs.reduce((result, fieldExpr) => {
-            var _a;
-            let key, value, elseExpr;
-            if (fieldExpr.includes(".")) {
-                [key, ...elseExpr] = fieldExpr.split(".");
-                value = elseExpr.join(".");
-            }
-            else {
-                key = "";
-                value = fieldExpr;
-            }
-            result[key] = ((_a = result[key]) !== null && _a !== void 0 ? _a : []).concat(value);
-            return result;
-        }, {});
-        return Object.keys(groups)
-            .map((key) => {
-            const group = groups[key];
-            // 일반 prop 처리
-            if (key === "") {
-                return group.map((propName) => {
-                    // uuid 개별 처리
-                    if (propName === "uuid") {
-                        return {
-                            nodeType: "plain",
-                            prop: {
-                                type: "string",
-                                name: "uuid",
-                                length: 128,
-                            },
-                            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",
-                        prop,
-                        children: [],
-                    };
-                });
-            }
-            // relation prop 처리
-            const prop = entity.propsDict[key];
-            if (!(0, types_1.isRelationProp)(prop)) {
-                throw new Error(`잘못된 FieldExpr ${key}.${group[0]}`);
-            }
-            const relEntity = entity_manager_1.EntityManager.get(prop.with);
-            // relation -One 에 id 필드 하나인 경우
-            if ((0, types_1.isBelongsToOneRelationProp)(prop) || (0, types_1.isOneToOneRelationProp)(prop)) {
-                if (group.length == 1 && (group[0] === "id" || group[0] == "id?")) {
-                    // id 하나만 있는지 체크해서, 하나만 있으면 상위 prop으로 id를 리턴
-                    const idProp = relEntity.propsDict.id;
-                    return {
-                        nodeType: "plain",
-                        prop: Object.assign(Object.assign({}, idProp), { name: key + "_id", nullable: prop.nullable }),
-                        children: [],
-                    };
-                }
-            }
-            // -One 그외의 경우 object로 리턴
-            // -Many의 경우 array로 리턴
-            // Recursive 로 뎁스 처리
-            const children = this.fieldExprsToPropNodes(group, relEntity);
-            const nodeType = (0, types_1.isBelongsToOneRelationProp)(prop) || (0, types_1.isOneToOneRelationProp)(prop)
-                ? "object"
-                : "array";
-            return {
-                prop,
-                children,
-                nodeType,
-            };
-        })
-            .flat();
-    }
-    getFieldExprs(prefix = "", maxDepth = 3, froms = []) {
-        return this.props
-            .map((prop) => {
-            const propName = [prefix, prop.name].filter((v) => v !== "").join(".");
-            if (propName === prefix) {
-                return null;
-            }
-            if ((0, types_1.isRelationProp)(prop)) {
-                if (maxDepth < 0) {
-                    return null;
-                }
-                if (froms.includes(prop.with)) {
-                    // 역방향 relation인 경우 제외
-                    return null;
-                }
-                // 정방향 relation인 경우 recursive 콜
-                const relMd = entity_manager_1.EntityManager.get(prop.with);
-                return relMd.getFieldExprs(propName, maxDepth - 1, [
-                    ...froms,
-                    this.id,
-                ]);
-            }
-            return propName;
-        })
-            .flat()
-            .filter((f) => f !== null);
-    }
-    getTableColumns() {
-        return this.props
-            .map((prop) => {
-            if (prop.type === "relation") {
-                if (prop.relationType === "BelongsToOne" ||
-                    (prop.relationType === "OneToOne" && prop.hasJoinColumn === true)) {
-                    return `${prop.name}_id`;
-                }
-                else {
-                    return null;
-                }
-            }
-            return prop.name;
-        })
-            .filter(utils_1.nonNullable);
-    }
-    registerModulePaths() {
-        const basePath = `${this.names.parentFs}`;
-        // base-scheme
-        entity_manager_1.EntityManager.setModulePath(`${this.id}BaseSchema`, `sonamu.generated`);
-        // subset
-        if (Object.keys(this.subsets).length > 0) {
-            entity_manager_1.EntityManager.setModulePath(`${this.id}SubsetKey`, `sonamu.generated`);
-            entity_manager_1.EntityManager.setModulePath(`${this.id}SubsetMapping`, `sonamu.generated`);
-            Object.keys(this.subsets).map((subsetKey) => {
-                entity_manager_1.EntityManager.setModulePath(`${this.id}Subset${subsetKey.toUpperCase()}`, `sonamu.generated`);
-            });
-        }
-        // enums
-        Object.keys(this.enumLabels).map((enumId) => {
-            entity_manager_1.EntityManager.setModulePath(enumId, `sonamu.generated`);
-        });
-        // types
-        const typesModulePath = `${basePath}/${this.names.parentFs}.types`;
-        const typesFileDistPath = path_1.default.join(sonamu_1.Sonamu.apiRootPath, `dist/application/${typesModulePath}.js`);
-        if (fs_extra_1.default.existsSync(typesFileDistPath)) {
-            const importPath = path_1.default.relative(__dirname, typesFileDistPath);
-            Promise.resolve(`${importPath}`).then(s => __importStar(require(s))).then((t) => {
-                this.types = Object.keys(t).reduce((result, key) => {
-                    entity_manager_1.EntityManager.setModulePath(key, typesModulePath);
-                    return Object.assign(Object.assign({}, result), { [key]: t[key] });
-                }, {});
-            });
-        }
-    }
-    registerTableSpecs() {
-        const uniqueIndexes = this.indexes.filter((idx) => idx.type === "unique");
-        entity_manager_1.EntityManager.setTableSpec({
-            name: this.table,
-            uniqueIndexes,
-        });
-    }
-    toJson() {
-        return {
-            id: this.id,
-            parentId: this.parentId,
-            table: this.table,
-            title: this.title,
-            props: this.props,
-            indexes: this.indexes,
-            subsets: this.subsets,
-            enums: this.enumLabels,
-        };
-    }
-    save() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // sort: subsets
-            const subsetRows = this.getSubsetRows();
-            this.subsets = Object.fromEntries(Object.entries(this.subsets).map(([subsetKey]) => {
-                return [
-                    subsetKey,
-                    this.subsetRowsToSubsetFields(subsetRows, subsetKey),
-                ];
-            }));
-            // save
-            const jsonPath = path_1.default.join(sonamu_1.Sonamu.apiRootPath, `src/application/${this.names.parentFs}/${this.names.fs}.entity.json`);
-            const json = this.toJson();
-            fs_extra_1.default.writeFileSync(jsonPath, yield prettier_1.default.format(JSON.stringify(json), {
-                parser: "json",
-            }));
-            // reload
-            yield entity_manager_1.EntityManager.register(json);
-        });
-    }
-    getSubsetRows(_subsets, prefixes = []) {
-        if (prefixes.length > 10) {
-            return [];
-        }
-        const subsets = _subsets !== null && _subsets !== void 0 ? _subsets : this.subsets;
-        const subsetKeys = Object.keys(subsets);
-        const allFields = lodash_1.default.uniq(subsetKeys.map((key) => subsets[key]).flat());
-        return this.props.map((prop) => {
-            if (prop.type === "relation" &&
-                allFields.find((f) => f.startsWith([...prefixes, prop.name].join(".") + "."))) {
-                const relEntity = entity_manager_1.EntityManager.get(prop.with);
-                const children = relEntity.getSubsetRows(subsets, [
-                    ...prefixes,
-                    `${prop.name}`,
-                ]);
-                return {
-                    field: prop.name,
-                    children,
-                    relationEntity: prop.with,
-                    prefixes,
-                    isOpen: children.length > 0,
-                    has: Object.fromEntries(subsetKeys.map((subsetKey) => {
-                        return [
-                            subsetKey,
-                            children.every((child) => child.has[subsetKey] === true),
-                        ];
-                    })),
-                };
-            }
-            return {
-                field: prop.name,
-                children: [],
-                relationEntity: prop.type === "relation" ? prop.with : undefined,
-                prefixes,
-                has: Object.fromEntries(subsetKeys.map((subsetKey) => {
-                    const subsetFields = subsets[subsetKey];
-                    const has = subsetFields.some((f) => {
-                        const field = [...prefixes, prop.name].join(".");
-                        return f === field || f.startsWith(field + ".");
-                    });
-                    return [subsetKey, has];
-                })),
-            };
-        });
-    }
-    subsetRowsToSubsetFields(subsetRows, subsetKey) {
-        return subsetRows
-            .map((subsetRow) => {
-            if (subsetRow.children.length > 0) {
-                return this.subsetRowsToSubsetFields(subsetRow.children, subsetKey);
-            }
-            else if (subsetRow.has[subsetKey]) {
-                return subsetRow.prefixes.concat(subsetRow.field).join(".");
-            }
-            else {
-                return null;
-            }
-        })
-            .filter(utils_1.nonNullable)
-            .flat();
-    }
-    createProp(prop, at) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!at) {
-                this.props.push(prop);
-            }
-            else {
-                this.props.splice(at, 0, prop);
-            }
-            yield this.save();
-        });
-    }
-    analyzeSubsetField(subsetField) {
-        const arr = subsetField.split(".");
-        let entityId = this.id;
-        const result = [];
-        for (let i = 0; i < arr.length; i++) {
-            const propName = arr[i];
-            result.push({
-                entityId,
-                propName,
-            });
-            const prop = entity_manager_1.EntityManager.get(entityId).props.find((p) => p.name === propName);
-            if (!prop) {
-                throw new Error(`${entityId}의 잘못된 서브셋키 ${subsetField}`);
-            }
-            if ((0, types_1.isRelationProp)(prop)) {
-                entityId = prop.with;
-            }
-        }
-        return result;
-    }
-    modifyProp(newProp, at) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 이전 프롭 이름 저장
-            const oldName = this.props[at].name;
-            // 저장할 엔티티
-            const entities = [this];
-            // 이름이 바뀐 경우
-            if (oldName !== newProp.name) {
-                // 전체 엔티티에서 현재 수정된 프롭을 참조하고 있는 모든 서브셋필드 찾아서 수정
-                const allEntityIds = entity_manager_1.EntityManager.getAllIds();
-                for (const relEntityId of allEntityIds) {
-                    const relEntity = entity_manager_1.EntityManager.get(relEntityId);
-                    const relEntitySubsetKeys = Object.keys(relEntity.subsets);
-                    for (const subsetKey of relEntitySubsetKeys) {
-                        const subset = relEntity.subsets[subsetKey];
-                        // 서브셋 필드를 순회하며, 엔티티-프롭 단위로 분석한 후 현재 엔티티-프롭과 일치하는 경우 수정 처리
-                        const modifiedSubsetFields = subset.map((subsetField) => {
-                            const analyzed = relEntity.analyzeSubsetField(subsetField);
-                            const modified = analyzed.map((a) => a.propName === oldName && a.entityId === this.id
-                                ? Object.assign(Object.assign({}, a), { propName: newProp.name }) : a);
-                            // 분석한 필드를 다시 서브셋 필드로 복구
-                            return modified.map((a) => a.propName).join(".");
-                        });
-                        if (subset.join(",") !== modifiedSubsetFields.join(",")) {
-                            relEntity.subsets[subsetKey] = modifiedSubsetFields;
-                            entities.push(relEntity);
-                        }
-                    }
-                }
-            }
-            // 프롭 수정
-            this.props[at] = newProp;
-            yield Promise.all(entities.map((entity) => __awaiter(this, void 0, void 0, function* () { return entity.save(); })));
-        });
-    }
-    delProp(at) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 이전 프롭 이름 저장
-            const oldName = this.props[at].name;
-            // 저장할 엔티티
-            const entities = [this];
-            // 전체 엔티티에서 현재 삭제된 프롭을 참조하고 있는 모든 서브셋필드 찾아서 제외
-            const allEntityIds = entity_manager_1.EntityManager.getAllIds();
-            for (const relEntityId of allEntityIds) {
-                const relEntity = entity_manager_1.EntityManager.get(relEntityId);
-                const relEntitySubsetKeys = Object.keys(relEntity.subsets);
-                for (const subsetKey of relEntitySubsetKeys) {
-                    const subset = relEntity.subsets[subsetKey];
-                    // 서브셋 필드를 순회하며, 엔티티-프롭 단위로 분석한 후 현재 엔티티-프롭과 일치하는 경우 이후의 필드를 제외
-                    const modifiedSubsetFields = subset
-                        .map((subsetField) => {
-                        const analyzed = relEntity.analyzeSubsetField(subsetField);
-                        if (analyzed.find((a) => a.propName === oldName && a.entityId === this.id)) {
-                            return null;
-                        }
-                        else {
-                            return subsetField;
-                        }
-                    })
-                        .filter(utils_1.nonNullable);
-                    if (subset.join(",") !== modifiedSubsetFields.join(",")) {
-                        relEntity.subsets[subsetKey] = modifiedSubsetFields;
-                        entities.push(relEntity);
-                    }
-                }
-            }
-            // 프롭 삭제
-            this.props.splice(at, 1);
-            yield Promise.all(entities.map((entity) => __awaiter(this, void 0, void 0, function* () { return entity.save(); })));
-        });
-    }
-    getEntityIdFromSubsetField(subsetField) {
-        if (subsetField.includes(".") === false) {
-            return this.id;
-        }
-        // 서브셋 필드의 마지막은 프롭이므로 제외
-        const arr = subsetField.split(".").slice(0, -1);
-        // 서브셋 필드를 내려가면서 마지막으로 relation된 엔티티를 찾음
-        const lastEntityId = arr.reduce((entityId, field) => {
-            const relProp = entity_manager_1.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}`);
-            }
-            return relProp.with;
-        }, this.id);
-        return lastEntityId;
-    }
-    moveProp(at, to) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const prop = this.props[at];
-            const newProps = [...this.props];
-            newProps.splice(to, 0, prop);
-            newProps.splice(at < to ? at : at + 1, 1);
-            this.props = newProps;
-            yield this.save();
-        });
-    }
-}
-exports.Entity = Entity;
-//# sourceMappingURL=entity.js.map