sonamu 0.2.38 → 0.2.40

package/dist/syncer/syncer.js

@@ -1,1119 +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 __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Syncer = void 0;
-const path_1 = __importStar(require("path"));
-const utils_1 = require("../utils/utils");
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const crypto_1 = __importDefault(require("crypto"));
-const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
-const lodash_1 = __importDefault(require("lodash"));
-const inflection_1 = __importDefault(require("inflection"));
-const entity_manager_1 = require("../entity/entity-manager");
-const typescript_1 = __importDefault(require("typescript"));
-const types_1 = require("../types/types");
-const decorators_1 = require("../api/decorators");
-const zod_1 = require("zod");
-const chalk_1 = __importDefault(require("chalk"));
-const types_2 = require("../types/types");
-const so_exceptions_1 = require("../exceptions/so-exceptions");
-const lodash_able_1 = require("../utils/lodash-able");
-const code_converters_1 = require("../api/code-converters");
-const generated_template_1 = require("../templates/generated.template");
-const init_types_template_1 = require("../templates/init_types.template");
-const entity_template_1 = require("../templates/entity.template");
-const model_template_1 = require("../templates/model.template");
-const model_test_template_1 = require("../templates/model_test.template");
-const service_template_1 = require("../templates/service.template");
-const view_form_template_1 = require("../templates/view_form.template");
-const view_list_template_1 = require("../templates/view_list.template");
-const prettier_1 = __importDefault(require("prettier"));
-const view_id_all_select_template_1 = require("../templates/view_id_all_select.template");
-const view_id_async_select_template_1 = require("../templates/view_id_async_select.template");
-const view_enums_dropdown_template_1 = require("../templates/view_enums_dropdown.template");
-const view_enums_select_template_1 = require("../templates/view_enums_select.template");
-const view_enums_buttonset_template_1 = require("../templates/view_enums_buttonset.template");
-const view_search_input_template_1 = require("../templates/view_search_input.template");
-const view_list_columns_template_1 = require("../templates/view_list_columns.template");
-const generated_http_template_1 = require("../templates/generated_http.template");
-const sonamu_1 = require("../api/sonamu");
-const child_process_1 = require("child_process");
-const generated_sso_template_1 = require("../templates/generated_sso.template");
-class Syncer {
-    get checksumsPath() {
-        return path_1.default.join(sonamu_1.Sonamu.apiRootPath, "/.so-checksum");
-    }
-    constructor() {
-        this.apis = [];
-        this.types = {};
-        this.models = {};
-        this.resolveParamDec = (paramDec, index = 0) => {
-            const name = paramDec.name;
-            const type = this.resolveTypeNode(paramDec.type);
-            if (name === undefined) {
-                console.log({ name, type, paramDec });
-            }
-            return {
-                name: name.escapedText ? name.escapedText.toString() : `nonameAt${index}`,
-                type,
-                optional: paramDec.optional === true,
-                defaultDef: paramDec === null || paramDec === void 0 ? void 0 : paramDec.defaultDef,
-            };
-        };
-    }
-    sync() {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const { targets } = sonamu_1.Sonamu.config.sync;
-            // 트리거와 무관하게 shared 분배
-            yield Promise.all(targets.map((target) => __awaiter(this, void 0, void 0, function* () {
-                const srcCodePath = path_1.default
-                    .join(__dirname, `../shared/${target}.shared.ts.txt`)
-                    .replace("/dist/", "/src/");
-                if (!fs_extra_1.default.existsSync(srcCodePath)) {
-                    return;
-                }
-                const dstCodePath = path_1.default.join(sonamu_1.Sonamu.appRootPath, target, "src/services/sonamu.shared.ts");
-                const srcChecksum = yield this.getChecksumOfFile(srcCodePath);
-                const dstChecksum = yield (() => __awaiter(this, void 0, void 0, function* () {
-                    if (fs_extra_1.default.existsSync(dstCodePath) === false) {
-                        return "";
-                    }
-                    return this.getChecksumOfFile(dstCodePath);
-                }))();
-                if (srcChecksum === dstChecksum) {
-                    return;
-                }
-                fs_extra_1.default.writeFileSync(dstCodePath, fs_extra_1.default.readFileSync(srcCodePath));
-            })));
-            // 현재 checksums
-            let currentChecksums = yield this.getCurrentChecksums();
-            // 이전 checksums
-            const previousChecksums = yield this.getPreviousChecksums();
-            // 비교
-            const isSame = (0, fast_deep_equal_1.default)(currentChecksums, previousChecksums);
-            if (isSame) {
-                const msg = "Every files are synced!";
-                const margin = (process.stdout.columns - msg.length) / 2;
-                console.log(chalk_1.default.black.bgGreen(" ".repeat(margin) + msg + " ".repeat(margin)));
-                return;
-            }
-            // 변경된 파일 찾기
-            const diff = lodash_1.default.differenceWith(currentChecksums, previousChecksums, lodash_1.default.isEqual);
-            const diffFiles = diff.map((r) => r.path);
-            console.log("Changed Files: ", diffFiles);
-            // 다른 부분 찾아 액션
-            const diffGroups = lodash_1.default.groupBy(diffFiles, (r) => {
-                const matched = r.match(/\.(model|types|functions|entity|generated)\.[tj]s/);
-                return matched[1];
-            });
-            // 변경된 파일들을 타입별로 분리하여 각 타입별 액션 처리
-            const diffTypes = Object.keys(diffGroups);
-            // 트리거: entity, types
-            // 액션: 스키마 생성
-            if (diffTypes.includes("entity") || diffTypes.includes("types")) {
-                console.log("// 액션: 스키마 생성");
-                yield this.actionGenerateSchemas();
-                // generated 싱크까지 동시에 처리 후 체크섬 갱신
-                diffGroups["generated"] = lodash_1.default.uniq([
-                    ...((_a = diffGroups["generated"]) !== null && _a !== void 0 ? _a : []),
-                    "/src/application/sonamu.generated.ts",
-                ]);
-                diffTypes.push("generated");
-                currentChecksums = yield this.getCurrentChecksums();
-            }
-            // 트리거: types, enums, generated 변경시
-            // 액션: 파일 싱크 types, enums, generated
-            if (diffTypes.includes("types") ||
-                diffTypes.includes("functions") ||
-                diffTypes.includes("generated")) {
-                console.log("// 액션: 파일 싱크 types / functions / generated");
-                const tsPaths = lodash_1.default.uniq([
-                    ...((_b = diffGroups["types"]) !== null && _b !== void 0 ? _b : []),
-                    ...((_c = diffGroups["functions"]) !== null && _c !== void 0 ? _c : []),
-                    ...((_d = diffGroups["generated"]) !== null && _d !== void 0 ? _d : []),
-                ].map((p) => p.replace("/dist/", "/src/").replace(".js", ".ts")));
-                yield this.actionSyncFilesToTargets(tsPaths);
-            }
-            // 트리거: model
-            if (diffTypes.includes("model")) {
-                const entityIds = this.getEntityIdFromPath(diffGroups["model"]);
-                console.log("// 액션: 서비스 생성");
-                yield this.actionGenerateServices(entityIds);
-                console.log("// 액션: HTTP파일 생성");
-                yield this.actionGenerateHttps(entityIds);
-            }
-            // 저장
-            yield this.saveChecksums(currentChecksums);
-        });
-    }
-    getEntityIdFromPath(filePaths) {
-        return lodash_1.default.uniq(filePaths.map((p) => {
-            const matched = p.match(/application\/(.+)\//);
-            return inflection_1.default.camelize(matched[1].replace(/\-/g, "_"));
-        }));
-    }
-    actionGenerateSchemas() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield Promise.all([
-                this.generateTemplate("generated_sso", {}, { overwrite: true }),
-                this.generateTemplate("generated", {}, { overwrite: true }),
-            ]))
-                .flat()
-                .flat();
-        });
-    }
-    actionGenerateServices(entityIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield Promise.all(entityIds.map((entityId) => __awaiter(this, void 0, void 0, function* () {
-                return this.generateTemplate("service", {
-                    entityId,
-                }, {
-                    overwrite: true,
-                });
-            }))))
-                .flat()
-                .flat();
-        });
-    }
-    actionGenerateHttps(entityIds) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield Promise.all(entityIds.map((entityId) => __awaiter(this, void 0, void 0, function* () {
-                return this.generateTemplate("generated_http", {
-                    entityId,
-                }, {
-                    overwrite: true,
-                });
-            }))))
-                .flat()
-                .flat();
-        });
-    }
-    copyFileWithReplaceCoreToShared(fromPath, toPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!fs_extra_1.default.existsSync(fromPath)) {
-                return;
-            }
-            const oldFileContent = fs_extra_1.default.readFileSync(fromPath).toString();
-            const newFileContent = (() => {
-                const nfc = oldFileContent.replace(/from "sonamu"/g, `from "src/services/sonamu.shared"`);
-                if (toPath.includes("/web/")) {
-                    return nfc.replace(/from "lodash";/g, `from "lodash-es";`);
-                }
-                else {
-                    return nfc;
-                }
-            })();
-            return fs_extra_1.default.writeFile(toPath, newFileContent);
-        });
-    }
-    actionSyncFilesToTargets(tsPaths) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { targets } = sonamu_1.Sonamu.config.sync;
-            const { dir: apiDir } = sonamu_1.Sonamu.config.api;
-            const { appRootPath } = sonamu_1.Sonamu;
-            return (yield Promise.all(targets.map((target) => __awaiter(this, void 0, void 0, function* () {
-                return Promise.all(tsPaths.map((src) => __awaiter(this, void 0, void 0, function* () {
-                    const realSrc = sonamu_1.Sonamu.apiRootPath + src;
-                    const dst = realSrc
-                        .replace(`/${apiDir}/`, `/${target}/`)
-                        .replace("/application/", "/services/");
-                    const dir = (0, path_1.dirname)(dst);
-                    if (!fs_extra_1.default.existsSync(dir)) {
-                        fs_extra_1.default.mkdirSync(dir, { recursive: true });
-                    }
-                    console.log("COPIED ", chalk_1.default.blue(dst.replace(appRootPath + "/", "")));
-                    yield this.copyFileWithReplaceCoreToShared(realSrc, dst);
-                    return dst;
-                })));
-            })))).flat();
-        });
-    }
-    getCurrentChecksums() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const PatternGroup = {
-                /* 원본 체크 */
-                entity: sonamu_1.Sonamu.apiRootPath + "/src/application/**/*.entity.json",
-                types: sonamu_1.Sonamu.apiRootPath + "/src/application/**/*.types.ts",
-                generated: sonamu_1.Sonamu.apiRootPath + "/src/application/sonamu.generated.ts",
-                functions: sonamu_1.Sonamu.apiRootPath + "/src/application/**/*.functions.ts",
-                /* compiled-JS 체크 */
-                model: sonamu_1.Sonamu.apiRootPath + "/dist/application/**/*.model.js",
-            };
-            const filePaths = (yield Promise.all(Object.entries(PatternGroup).map(([_fileType, pattern]) => __awaiter(this, void 0, void 0, function* () {
-                return (0, utils_1.globAsync)(pattern);
-            }))))
-                .flat()
-                .sort();
-            const fileChecksums = yield Promise.all(filePaths.map((filePath) => __awaiter(this, void 0, void 0, function* () {
-                return {
-                    path: filePath.substring(sonamu_1.Sonamu.apiRootPath.length),
-                    checksum: yield this.getChecksumOfFile(filePath),
-                };
-            })));
-            return fileChecksums;
-        });
-    }
-    getPreviousChecksums() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (fs_extra_1.default.existsSync(this.checksumsPath) === false) {
-                return [];
-            }
-            const previousChecksums = (yield fs_extra_1.default.readJSON(this.checksumsPath));
-            return previousChecksums;
-        });
-    }
-    saveChecksums(checksums) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield fs_extra_1.default.writeJSON(this.checksumsPath, checksums, {
-                spaces: 2,
-            });
-            console.debug("checksum saved", this.checksumsPath);
-        });
-    }
-    getChecksumOfFile(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                const hash = crypto_1.default.createHash("sha1");
-                const input = fs_extra_1.default.createReadStream(filePath);
-                input.on("error", reject);
-                input.on("data", function (chunk) {
-                    hash.update(chunk);
-                });
-                input.on("close", function () {
-                    resolve(hash.digest("hex"));
-                });
-            });
-        });
-    }
-    readApisFromFile(filePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sourceFile = typescript_1.default.createSourceFile(filePath, fs_extra_1.default.readFileSync(filePath).toString(), typescript_1.default.ScriptTarget.Latest);
-            const methods = [];
-            let modelName = "UnknownModel";
-            let methodName = "unknownMethod";
-            const visitor = (node) => {
-                var _a;
-                if (typescript_1.default.isClassDeclaration(node)) {
-                    if (node.name && typescript_1.default.isIdentifier(node.name)) {
-                        modelName = node.name.escapedText.toString().replace(/Class$/, "");
-                    }
-                }
-                if (typescript_1.default.isMethodDeclaration(node)) {
-                    if (typescript_1.default.isIdentifier(node.name)) {
-                        methodName = node.name.escapedText.toString();
-                    }
-                    const typeParameters = ((_a = node.typeParameters) !== null && _a !== void 0 ? _a : []).map((typeParam) => {
-                        const tp = typeParam;
-                        return {
-                            t: "type-param",
-                            id: tp.name.escapedText.toString(),
-                            constraint: tp.constraint
-                                ? this.resolveTypeNode(tp.constraint)
-                                : undefined,
-                        };
-                    });
-                    const parameters = node.parameters.map((paramDec, index) => {
-                        const defaultDef = this.printNode(paramDec.initializer, sourceFile);
-                        // 기본값이 있는 경우 paramDec.type가 undefined로 나옴
-                        return this.resolveParamDec({
-                            name: paramDec.name,
-                            type: paramDec.type,
-                            optional: paramDec.questionToken !== undefined ||
-                                paramDec.initializer !== undefined,
-                            defaultDef,
-                        }, index);
-                    });
-                    if (node.type === undefined) {
-                        throw new Error(`리턴 타입이 기재되지 않은 메소드 ${modelName}.${methodName}`);
-                    }
-                    const returnType = this.resolveTypeNode(node.type);
-                    methods.push({
-                        modelName,
-                        methodName,
-                        typeParameters,
-                        parameters,
-                        returnType,
-                    });
-                }
-                typescript_1.default.forEachChild(node, visitor);
-            };
-            visitor(sourceFile);
-            if (methods.length === 0) {
-                return [];
-            }
-            // 현재 파일의 등록된 API 필터
-            const currentModelApis = decorators_1.registeredApis.filter((api) => {
-                return methods.find((method) => method.modelName === api.modelName &&
-                    method.methodName === api.methodName);
-            });
-            // 등록된 API에 현재 메소드 타입 정보 확장
-            const extendedApis = currentModelApis.map((api) => {
-                const foundMethod = methods.find((method) => method.modelName === api.modelName &&
-                    method.methodName === api.methodName);
-                return Object.assign(Object.assign({}, api), { typeParameters: foundMethod.typeParameters, parameters: foundMethod.parameters, returnType: foundMethod.returnType });
-            });
-            return extendedApis;
-        });
-    }
-    resolveTypeNode(typeNode) {
-        var _a;
-        switch (typeNode === null || typeNode === void 0 ? void 0 : typeNode.kind) {
-            case typescript_1.default.SyntaxKind.AnyKeyword:
-                return "any";
-            case typescript_1.default.SyntaxKind.UnknownKeyword:
-                return "unknown";
-            case typescript_1.default.SyntaxKind.StringKeyword:
-                return "string";
-            case typescript_1.default.SyntaxKind.NumberKeyword:
-                return "number";
-            case typescript_1.default.SyntaxKind.BooleanKeyword:
-                return "boolean";
-            case typescript_1.default.SyntaxKind.UndefinedKeyword:
-                return "undefined";
-            case typescript_1.default.SyntaxKind.NullKeyword:
-                return "null";
-            case typescript_1.default.SyntaxKind.VoidKeyword:
-                return "void";
-            case typescript_1.default.SyntaxKind.LiteralType:
-                const literal = typeNode.literal;
-                if (typescript_1.default.isStringLiteral(literal)) {
-                    return {
-                        t: "string-literal",
-                        value: literal.text,
-                    };
-                }
-                else if (typescript_1.default.isNumericLiteral(literal)) {
-                    return {
-                        t: "numeric-literal",
-                        value: Number(literal.text),
-                    };
-                }
-                else {
-                    if (literal.kind === typescript_1.default.SyntaxKind.NullKeyword) {
-                        return "null";
-                    }
-                    else if (literal.kind === typescript_1.default.SyntaxKind.UndefinedKeyword) {
-                        return "undefined";
-                    }
-                    else if (literal.kind === typescript_1.default.SyntaxKind.TrueKeyword) {
-                        return "true";
-                    }
-                    else if (literal.kind === typescript_1.default.SyntaxKind.FalseKeyword) {
-                        return "false";
-                    }
-                    throw new Error("알 수 없는 리터럴");
-                }
-            case typescript_1.default.SyntaxKind.ArrayType:
-                const arrNode = typeNode;
-                return {
-                    t: "array",
-                    elementsType: this.resolveTypeNode(arrNode.elementType),
-                };
-            case typescript_1.default.SyntaxKind.TypeLiteral:
-                const literalNode = typeNode;
-                return {
-                    t: "object",
-                    props: literalNode.members.map((member) => {
-                        if (typescript_1.default.isIndexSignatureDeclaration(member)) {
-                            const res = this.resolveParamDec({
-                                name: member.parameters[0].name,
-                                type: member.parameters[0].type,
-                            });
-                            return this.resolveParamDec({
-                                name: {
-                                    escapedText: `[${res.name}${res.optional ? "?" : ""}: ${res.type}]`,
-                                },
-                                type: member.type,
-                            });
-                        }
-                        else {
-                            return this.resolveParamDec({
-                                name: member.name,
-                                type: member.type,
-                                optional: member.questionToken !== undefined,
-                            });
-                        }
-                    }),
-                };
-            case typescript_1.default.SyntaxKind.TypeReference:
-                return {
-                    t: "ref",
-                    id: typeNode.typeName.escapedText.toString(),
-                    args: (_a = typeNode.typeArguments) === null || _a === void 0 ? void 0 : _a.map((typeArg) => this.resolveTypeNode(typeArg)),
-                };
-            case typescript_1.default.SyntaxKind.UnionType:
-                return {
-                    t: "union",
-                    types: typeNode.types.map((type) => this.resolveTypeNode(type)),
-                };
-            case typescript_1.default.SyntaxKind.IntersectionType:
-                return {
-                    t: "intersection",
-                    types: typeNode.types.map((type) => this.resolveTypeNode(type)),
-                };
-            case typescript_1.default.SyntaxKind.IndexedAccessType:
-                return {
-                    t: "indexed-access",
-                    object: this.resolveTypeNode(typeNode.objectType),
-                    index: this.resolveTypeNode(typeNode.indexType),
-                };
-            case typescript_1.default.SyntaxKind.TupleType:
-                if (typescript_1.default.isTupleTypeNode(typeNode)) {
-                    return {
-                        t: "tuple-type",
-                        elements: typeNode.elements.map((elem) => this.resolveTypeNode(elem)),
-                    };
-                }
-                break;
-            case undefined:
-                throw new Error(`typeNode undefined`);
-        }
-        console.debug(typeNode);
-        throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);
-    }
-    printNode(node, sourceFile) {
-        if (node === undefined) {
-            return undefined;
-        }
-        const printer = typescript_1.default.createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed });
-        return printer.printNode(typescript_1.default.EmitHint.Unspecified, node, sourceFile);
-    }
-    autoloadApis() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pathPattern = path_1.default.join(sonamu_1.Sonamu.apiRootPath, "/src/application/**/*.model.ts");
-            // console.debug(chalk.yellow(`autoload:APIs @ ${pathPattern}`));
-            const filePaths = yield (0, utils_1.globAsync)(pathPattern);
-            const result = yield Promise.all(filePaths.map((filePath) => this.readApisFromFile(filePath)));
-            this.apis = result.flat();
-            return this.apis;
-        });
-    }
-    autoloadModels() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pathPattern = path_1.default.join(sonamu_1.Sonamu.apiRootPath, "dist/application/**/*.model.js");
-            // console.debug(chalk.yellow(`autoload:models @ ${pathPattern}`));
-            const filePaths = (yield (0, utils_1.globAsync)(pathPattern)).filter((path) => {
-                // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
-                // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
-                const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
-                return fs_extra_1.default.existsSync(srcPath);
-            });
-            const modules = yield (0, utils_1.importMultiple)(filePaths);
-            const functions = modules
-                .map(({ imported }) => Object.entries(imported))
-                .flat();
-            this.models = Object.fromEntries(functions.filter(([name]) => name.endsWith("Model")));
-            return this.models;
-        });
-    }
-    autoloadTypes(doRefresh = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!doRefresh && Object.keys(this.types).length > 0) {
-                return this.types;
-            }
-            const pathPatterns = [
-                path_1.default.join(sonamu_1.Sonamu.apiRootPath, "/dist/application/**/*.types.js"),
-                path_1.default.join(sonamu_1.Sonamu.apiRootPath, "/dist/application/**/*.generated.js"),
-            ];
-            // console.debug(chalk.magenta(`autoload:types @ ${pathPatterns.join("\n")}`));
-            const filePaths = (yield Promise.all(pathPatterns.map((pattern) => (0, utils_1.globAsync)(pattern))))
-                .flat()
-                .filter((path) => {
-                // src 디렉터리 내에 있는 해당 파일이 존재할 경우에만 로드
-                // 삭제된 파일이지만 dist에 남아있는 경우 BaseSchema undefined 에러 방지
-                const srcPath = path.replace("/dist/", "/src/").replace(".js", ".ts");
-                return fs_extra_1.default.existsSync(srcPath);
-            });
-            const modules = yield (0, utils_1.importMultiple)(filePaths, doRefresh);
-            const functions = modules
-                .map(({ imported }) => Object.entries(imported))
-                .flat();
-            this.types = Object.fromEntries(functions.filter(([, f]) => f instanceof zod_1.z.ZodType));
-            return this.types;
-        });
-    }
-    getTemplate(key) {
-        if (key === "entity") {
-            return new entity_template_1.Template__entity();
-        }
-        else if (key === "init_types") {
-            return new init_types_template_1.Template__init_types();
-        }
-        else if (key === "generated") {
-            return new generated_template_1.Template__generated();
-        }
-        else if (key === "generated_sso") {
-            return new generated_sso_template_1.Template__generated_sso();
-        }
-        else if (key === "generated_http") {
-            return new generated_http_template_1.Template__generated_http();
-        }
-        else if (key === "model") {
-            return new model_template_1.Template__model();
-        }
-        else if (key === "model_test") {
-            return new model_test_template_1.Template__model_test();
-        }
-        else if (key === "service") {
-            return new service_template_1.Template__service();
-        }
-        else if (key === "view_list") {
-            return new view_list_template_1.Template__view_list();
-        }
-        else if (key === "view_list_columns") {
-            return new view_list_columns_template_1.Template__view_list_columns();
-        }
-        else if (key === "view_search_input") {
-            return new view_search_input_template_1.Template__view_search_input();
-        }
-        else if (key === "view_form") {
-            return new view_form_template_1.Template__view_form();
-        }
-        else if (key === "view_id_all_select") {
-            return new view_id_all_select_template_1.Template__view_id_all_select();
-        }
-        else if (key === "view_id_async_select") {
-            return new view_id_async_select_template_1.Template__view_id_async_select();
-        }
-        else if (key === "view_enums_select") {
-            return new view_enums_select_template_1.Template__view_enums_select();
-        }
-        else if (key === "view_enums_dropdown") {
-            return new view_enums_dropdown_template_1.Template__view_enums_dropdown();
-        }
-        else if (key === "view_enums_buttonset") {
-            return new view_enums_buttonset_template_1.Template__view_enums_buttonset();
-        }
-        else {
-            throw new so_exceptions_1.BadRequestException(`잘못된 템플릿 키 ${key}`);
-        }
-    }
-    renderTemplate(key, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const template = this.getTemplate(key);
-            let extra = [];
-            if (["service", "generated_http", "model", "view_list", "view_form"].includes(key)) {
-                const entityId = options.entityId;
-                if (key === "service" || key === "generated_http") {
-                    // service 필요 정보 (API 리스트)
-                    const entity = entity_manager_1.EntityManager.get(entityId);
-                    const modelTsPath = `${path_1.default.join(sonamu_1.Sonamu.apiRootPath, "/src/application")}/${entity.names.fs}/${entity.names.fs}.model.ts`;
-                    extra = [yield this.readApisFromFile(modelTsPath)];
-                }
-                else if (key === "view_list" || key === "model") {
-                    // view_list 필요 정보 (컬럼 노드, 리스트파라미터 노드)
-                    const columnsNode = yield this.getColumnsNode(entityId, "A");
-                    const listParamsZodType = yield this.getZodTypeById(`${entityId}ListParams`);
-                    const listParamsNode = this.zodTypeToRenderingNode(listParamsZodType);
-                    extra = [columnsNode, listParamsNode];
-                }
-                else if (key === "view_form") {
-                    // view_form 필요 정보 (세이브파라미터 노드)
-                    const saveParamsZodType = yield this.getZodTypeById(`${entityId}SaveParams`);
-                    const saveParamsNode = this.zodTypeToRenderingNode(saveParamsZodType);
-                    extra = [saveParamsNode];
-                }
-            }
-            const rendered = yield template.render(options, ...extra);
-            const resolved = yield this.resolveRenderedTemplate(key, rendered);
-            let preTemplateResolved = [];
-            if (rendered.preTemplates) {
-                preTemplateResolved = (yield Promise.all(rendered.preTemplates.map(({ key, options }) => {
-                    return this.renderTemplate(key, options);
-                }))).flat();
-            }
-            return [resolved, ...preTemplateResolved];
-        });
-    }
-    resolveRenderedTemplate(key, result) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { target, path: filePath, body, importKeys, customHeaders } = result;
-            // import 할 대상의 대상 path 추출
-            const importDefs = importKeys
-                .reduce((r, importKey) => {
-                const modulePath = entity_manager_1.EntityManager.getModulePath(importKey);
-                let importPath = modulePath;
-                if (modulePath.includes("/") || modulePath.includes(".")) {
-                    importPath = (0, lodash_able_1.wrapIf)(path_1.default.relative(path_1.default.dirname(filePath), modulePath), (p) => [p.startsWith(".") === false, "./" + p]);
-                }
-                // 같은 파일에서 import 하는 경우 keys 로 나열 처리
-                const existsOne = r.find((importDef) => importDef.from === importPath);
-                if (existsOne) {
-                    existsOne.keys = lodash_1.default.uniq(existsOne.keys.concat(importKey));
-                }
-                else {
-                    r.push({
-                        keys: [importKey],
-                        from: importPath,
-                    });
-                }
-                return r;
-            }, [])
-                // 셀프 참조 방지
-                .filter((importDef) => filePath.endsWith(importDef.from.replace("./", "") + ".ts") === false);
-            // 커스텀 헤더 포함하여 헤더 생성
-            const header = [
-                ...(customHeaders !== null && customHeaders !== void 0 ? customHeaders : []),
-                ...importDefs.map((importDef) => `import { ${importDef.keys.join(", ")} } from '${importDef.from}'`),
-            ].join("\n");
-            const formatted = yield (() => __awaiter(this, void 0, void 0, function* () {
-                if (key === "generated_http") {
-                    return [header, body].join("\n\n");
-                }
-                else {
-                    return prettier_1.default.format([header, body].join("\n\n"), {
-                        parser: key === "entity" ? "json" : "typescript",
-                    });
-                }
-            }))();
-            return {
-                path: target + "/" + filePath,
-                code: formatted,
-            };
-        });
-    }
-    writeCodeToPath(pathAndCode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { targets } = sonamu_1.Sonamu.config.sync;
-            const { appRootPath } = sonamu_1.Sonamu;
-            const filePath = `${sonamu_1.Sonamu.appRootPath}/${pathAndCode.path}`;
-            const dstFilePaths = lodash_1.default.uniq(targets.map((target) => filePath.replace("/:target/", `/${target}/`)));
-            return yield Promise.all(dstFilePaths.map((dstFilePath) => __awaiter(this, void 0, void 0, function* () {
-                const dir = path_1.default.dirname(dstFilePath);
-                if (fs_extra_1.default.existsSync(dir) === false) {
-                    fs_extra_1.default.mkdirSync(dir, { recursive: true });
-                }
-                fs_extra_1.default.writeFileSync(dstFilePath, pathAndCode.code);
-                console.log("GENERATED ", chalk_1.default.blue(dstFilePath.replace(appRootPath + "/", "")));
-                return dstFilePath;
-            })));
-        });
-    }
-    generateTemplate(key, templateOptions, _generateOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const generateOptions = Object.assign({ overwrite: false }, _generateOptions);
-            // 키 children
-            const keys = [key];
-            // 템플릿 렌더
-            const pathAndCodes = (yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
-                return yield this.renderTemplate(key, templateOptions);
-            })))).flat();
-            const filteredPathAndCodes = (() => {
-                if (generateOptions.overwrite === true) {
-                    return pathAndCodes;
-                }
-                else {
-                    return pathAndCodes.filter((pathAndCode) => {
-                        const { targets } = sonamu_1.Sonamu.config.sync;
-                        const filePath = `${sonamu_1.Sonamu.appRootPath}/${pathAndCode.path}`;
-                        const dstFilePaths = targets.map((target) => filePath.replace("/:target/", `/${target}/`));
-                        return dstFilePaths.every((dstPath) => fs_extra_1.default.existsSync(dstPath) === false);
-                    });
-                }
-            })();
-            if (filteredPathAndCodes.length === 0) {
-                throw new so_exceptions_1.AlreadyProcessedException("이미 경로에 모든 파일이 존재합니다.");
-            }
-            return Promise.all(filteredPathAndCodes.map((pathAndCode) => this.writeCodeToPath(pathAndCode)));
-        });
-    }
-    checkExistsGenCode(entityId, templateKey, enumId) {
-        const { target, path: genPath } = this.getTemplate(templateKey).getTargetAndPath(entity_manager_1.EntityManager.getNamesFromId(entityId), enumId);
-        const fullPath = path_1.default.join(sonamu_1.Sonamu.appRootPath, target, genPath);
-        const subPath = path_1.default.join(target, genPath);
-        return {
-            subPath,
-            fullPath,
-            isExists: fs_extra_1.default.existsSync(fullPath),
-        };
-    }
-    checkExists(entityId, enums) {
-        const keys = types_2.TemplateKey.options;
-        const names = entity_manager_1.EntityManager.getNamesFromId(entityId);
-        const enumsKeys = Object.keys(enums).filter((name) => name !== names.constant);
-        return keys.reduce((result, key) => {
-            const tpl = this.getTemplate(key);
-            if (key.startsWith("view_enums")) {
-                enumsKeys.map((componentId) => {
-                    const { target, path: p } = tpl.getTargetAndPath(names, componentId);
-                    result[`${key}__${componentId}`] = fs_extra_1.default.existsSync(path_1.default.join(sonamu_1.Sonamu.appRootPath, target, p));
-                });
-                return result;
-            }
-            const { target, path: p } = tpl.getTargetAndPath(names);
-            const { targets } = sonamu_1.Sonamu.config.sync;
-            if (target.includes(":target")) {
-                targets.map((t) => {
-                    result[`${key}__${t}`] = fs_extra_1.default.existsSync(path_1.default.join(sonamu_1.Sonamu.appRootPath, target.replace(":target", t), p));
-                });
-            }
-            else {
-                result[key] = fs_extra_1.default.existsSync(path_1.default.join(sonamu_1.Sonamu.appRootPath, target, p));
-            }
-            return result;
-        }, {});
-    }
-    getZodTypeById(zodTypeId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const modulePath = entity_manager_1.EntityManager.getModulePath(zodTypeId);
-            const moduleAbsPath = path_1.default.join(sonamu_1.Sonamu.apiRootPath, "dist", "application", modulePath + ".js");
-            const importPath = "./" + path_1.default.relative(__dirname, moduleAbsPath);
-            const imported = yield Promise.resolve(`${importPath}`).then(s => __importStar(require(s)));
-            if (!imported[zodTypeId]) {
-                throw new Error(`존재하지 않는 zodTypeId ${zodTypeId}`);
-            }
-            return imported[zodTypeId].describe(zodTypeId);
-        });
-    }
-    propNodeToZodType(propNode) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (propNode.nodeType === "plain") {
-                return this.propToZodType(propNode.prop);
-            }
-            else if (propNode.nodeType === "array") {
-                if (propNode.prop === undefined) {
-                    throw new Error();
-                }
-                else if (propNode.children.length > 0) {
-                    return (yield this.propNodeToZodType(Object.assign(Object.assign({}, propNode), { nodeType: "object" }))).array();
-                }
-                else {
-                    const innerType = yield this.propToZodType(propNode.prop);
-                    if (propNode.prop.nullable === true) {
-                        return zod_1.z.array(innerType).nullable();
-                    }
-                    else {
-                        return zod_1.z.array(innerType);
-                    }
-                }
-            }
-            else if (propNode.nodeType === "object") {
-                const obj = yield propNode.children.reduce((promise, childPropNode) => __awaiter(this, void 0, void 0, function* () {
-                    const result = yield promise;
-                    result[childPropNode.prop.name] =
-                        yield this.propNodeToZodType(childPropNode);
-                    return result;
-                }), {});
-                if (((_a = propNode.prop) === null || _a === void 0 ? void 0 : _a.nullable) === true) {
-                    return zod_1.z.object(obj).nullable();
-                }
-                else {
-                    return zod_1.z.object(obj);
-                }
-            }
-            else {
-                throw Error;
-            }
-        });
-    }
-    propToZodType(prop) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let zodType = zod_1.z.unknown();
-            if ((0, types_1.isIntegerProp)(prop)) {
-                zodType = zod_1.z.number().int();
-            }
-            else if ((0, types_1.isBigIntegerProp)(prop)) {
-                zodType = zod_1.z.bigint();
-            }
-            else if ((0, types_1.isTextProp)(prop)) {
-                zodType = zod_1.z.string().max((0, code_converters_1.getTextTypeLength)(prop.textType));
-            }
-            else if ((0, types_1.isEnumProp)(prop)) {
-                zodType = yield this.getZodTypeById(prop.id);
-            }
-            else if ((0, types_1.isStringProp)(prop)) {
-                zodType = zod_1.z.string().max(prop.length);
-            }
-            else if ((0, types_1.isFloatProp)(prop) || (0, types_1.isDoubleProp)(prop)) {
-                zodType = zod_1.z.number();
-            }
-            else if ((0, types_1.isDecimalProp)(prop)) {
-                zodType = zod_1.z.string();
-            }
-            else if ((0, types_1.isBooleanProp)(prop)) {
-                zodType = zod_1.z.boolean();
-            }
-            else if ((0, types_1.isDateProp)(prop)) {
-                zodType = zod_1.z.string().length(10);
-            }
-            else if ((0, types_1.isTimeProp)(prop)) {
-                zodType = zod_1.z.string().length(8);
-            }
-            else if ((0, types_1.isDateTimeProp)(prop)) {
-                zodType = types_1.SQLDateTimeString;
-            }
-            else if ((0, types_1.isTimestampProp)(prop)) {
-                zodType = types_1.SQLDateTimeString;
-            }
-            else if ((0, types_1.isJsonProp)(prop)) {
-                zodType = yield this.getZodTypeById(prop.id);
-            }
-            else if ((0, types_1.isUuidProp)(prop)) {
-                zodType = zod_1.z.string().uuid();
-            }
-            else if ((0, types_1.isVirtualProp)(prop)) {
-                zodType = yield this.getZodTypeById(prop.id);
-            }
-            else if ((0, types_1.isRelationProp)(prop)) {
-                if ((0, types_1.isBelongsToOneRelationProp)(prop) ||
-                    ((0, types_1.isOneToOneRelationProp)(prop) && prop.hasJoinColumn)) {
-                    zodType = zod_1.z.number().int();
-                }
-            }
-            else {
-                throw new Error(`prop을 zodType으로 변환하는데 실패 ${prop}}`);
-            }
-            if (prop.unsigned) {
-                zodType = zodType.nonnegative();
-            }
-            if (prop.nullable) {
-                zodType = zodType.nullable();
-            }
-            return zodType;
-        });
-    }
-    resolveRenderType(key, zodType) {
-        if (zodType instanceof zod_1.z.ZodString) {
-            if (key.includes("img") || key.includes("image")) {
-                return "string-image";
-            }
-            else if (zodType.description === "SQLDateTimeString") {
-                return "string-datetime";
-            }
-            else if (key.endsWith("date")) {
-                return "string-date";
-            }
-            else {
-                return "string-plain";
-            }
-        }
-        else if (zodType instanceof zod_1.z.ZodNumber) {
-            if (key === "id") {
-                return "number-id";
-            }
-            else if (key.endsWith("_id")) {
-                return "number-fk_id";
-            }
-            else {
-                return "number-plain";
-            }
-        }
-        else if (zodType instanceof zod_1.z.ZodBoolean) {
-            return "boolean";
-        }
-        else if (zodType instanceof zod_1.z.ZodEnum) {
-            return "enums";
-        }
-        else if (zodType instanceof zod_1.z.ZodRecord) {
-            return "record";
-        }
-        else if (zodType instanceof zod_1.z.ZodAny || zodType instanceof zod_1.z.ZodUnknown) {
-            return "string-plain";
-        }
-        else if (zodType instanceof zod_1.z.ZodUnion) {
-            return "string-plain";
-        }
-        else if (zodType instanceof zod_1.z.ZodLiteral) {
-            return "string-plain";
-        }
-        else {
-            throw new Error(`타입 파싱 불가 ${key} ${zodType._def.typeName}`);
-        }
-    }
-    zodTypeToRenderingNode(zodType, baseKey = "root") {
-        const def = {
-            name: baseKey,
-            label: inflection_1.default.camelize(baseKey, false),
-            zodType,
-        };
-        if (zodType instanceof zod_1.z.ZodObject) {
-            const columnKeys = Object.keys(zodType.shape);
-            const children = columnKeys.map((key) => {
-                const innerType = zodType.shape[key];
-                return this.zodTypeToRenderingNode(innerType, key);
-            });
-            return Object.assign(Object.assign({}, def), { renderType: "object", children });
-        }
-        else if (zodType instanceof zod_1.z.ZodArray) {
-            const innerType = zodType._def.type;
-            if (innerType instanceof zod_1.z.ZodString && baseKey.includes("images")) {
-                return Object.assign(Object.assign({}, def), { renderType: "array-images" });
-            }
-            return Object.assign(Object.assign({}, def), { renderType: "array", element: this.zodTypeToRenderingNode(innerType, baseKey) });
-        }
-        else if (zodType instanceof zod_1.z.ZodUnion) {
-            const optionNodes = zodType._def.options.map((opt) => this.zodTypeToRenderingNode(opt, baseKey));
-            // TODO: ZodUnion이 들어있는 경우 핸들링
-            return optionNodes[0];
-        }
-        else if (zodType instanceof zod_1.z.ZodOptional) {
-            return Object.assign(Object.assign({}, this.zodTypeToRenderingNode(zodType._def.innerType, baseKey)), { optional: true });
-        }
-        else if (zodType instanceof zod_1.z.ZodNullable) {
-            return Object.assign(Object.assign({}, this.zodTypeToRenderingNode(zodType._def.innerType, baseKey)), { nullable: true });
-        }
-        else {
-            return Object.assign(Object.assign({}, def), { renderType: this.resolveRenderType(baseKey, zodType) });
-        }
-    }
-    getColumnsNode(entityId, subsetKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entity = yield entity_manager_1.EntityManager.get(entityId);
-            const subsetA = entity.subsets[subsetKey];
-            if (subsetA === undefined) {
-                throw new so_exceptions_1.ServiceUnavailableException("SubsetA 가 없습니다.");
-            }
-            const propNodes = entity.fieldExprsToPropNodes(subsetA);
-            const rootPropNode = {
-                nodeType: "object",
-                children: propNodes,
-            };
-            const columnsZodType = (yield this.propNodeToZodType(rootPropNode));
-            const columnsNode = this.zodTypeToRenderingNode(columnsZodType);
-            columnsNode.children = columnsNode.children.map((child) => {
-                if (child.renderType === "object") {
-                    const pickedCol = child.children.find((cc) => ["title", "name"].includes(cc.name));
-                    if (pickedCol) {
-                        return Object.assign(Object.assign({}, child), { renderType: "object-pick", config: {
-                                picked: pickedCol.name,
-                            } });
-                    }
-                    else {
-                        return child;
-                    }
-                }
-                else if (child.renderType === "array" &&
-                    child.element &&
-                    child.element.renderType === "object") {
-                    const pickedCol = child.element.children.find((cc) => ["title", "name"].includes(cc.name));
-                    if (pickedCol) {
-                        return Object.assign(Object.assign({}, child), { element: Object.assign(Object.assign({}, child.element), { renderType: "object-pick", config: {
-                                    picked: pickedCol.name,
-                                } }) });
-                    }
-                    else {
-                        return child;
-                    }
-                }
-                return child;
-            });
-            return columnsNode;
-        });
-    }
-    createEntity(entityId, parentId, table, title) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!/^[A-Z][a-zA-Z0-9]*$/.test(entityId)) {
-                throw new so_exceptions_1.BadRequestException("entityId는 CamelCase 형식이어야 합니다.");
-            }
-            yield this.generateTemplate("entity", {
-                entityId,
-                parentId,
-                table,
-                title,
-            });
-            // reload entities
-            yield entity_manager_1.EntityManager.reload();
-            // generate schemas
-            yield this.actionGenerateSchemas();
-            // generate types
-            if (parentId === undefined) {
-                yield this.generateTemplate("init_types", {
-                    entityId,
-                });
-            }
-        });
-    }
-    delEntity(entityId) {
-        var _a, e_1, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const entity = entity_manager_1.EntityManager.get(entityId);
-            const delPaths = (() => {
-                if (entity.parentId) {
-                    return [
-                        `${sonamu_1.Sonamu.apiRootPath}/src/application/${entity.names.parentFs}/${entity.names.fs}.entity.json`,
-                    ];
-                }
-                else {
-                    return [
-                        `${sonamu_1.Sonamu.apiRootPath}/src/application/${entity.names.fs}`,
-                        `${sonamu_1.Sonamu.apiRootPath}/dist/application/${entity.names.fs}`,
-                        ...sonamu_1.Sonamu.config.sync.targets
-                            .map((target) => [
-                            `${sonamu_1.Sonamu.appRootPath}/${target}/src/services/${entity.names.fs}`,
-                        ])
-                            .flat(),
-                    ];
-                }
-            })(); // iife
-            try {
-                for (var _d = true, delPaths_1 = __asyncValues(delPaths), delPaths_1_1; delPaths_1_1 = yield delPaths_1.next(), _a = delPaths_1_1.done, !_a; _d = true) {
-                    _c = delPaths_1_1.value;
-                    _d = false;
-                    const delPath = _c;
-                    if (fs_extra_1.default.existsSync(delPath)) {
-                        console.log(chalk_1.default.red(`DELETE ${delPath}`));
-                        (0, child_process_1.execSync)(`rm -rf ${delPath}`);
-                    }
-                    else {
-                        console.log(chalk_1.default.yellow(`NOT_EXISTS ${delPath}`));
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = delPaths_1.return)) yield _b.call(delPaths_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            // reload entities
-            yield entity_manager_1.EntityManager.reload();
-            return { delPaths };
-        });
-    }
-}
-exports.Syncer = Syncer;
-//# sourceMappingURL=syncer.js.map