sonamu 0.0.1 → 0.0.3

package/dist/syncer/syncer.js

@@ -0,0 +1,1001 @@
+"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.Syncer = void 0;
+const path_1 = __importStar(require("path"));
+const utils_1 = require("../utils/utils");
+const fs_extra_1 = __importStar(require("fs-extra"));
+const crypto_1 = __importDefault(require("crypto"));
+const fast_deep_equal_1 = __importDefault(require("fast-deep-equal"));
+const lodash_1 = require("lodash");
+const inflection_1 = require("inflection");
+const smd_manager_1 = require("../smd/smd-manager");
+const ts = __importStar(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_enums_template_1 = require("../templates/init_enums.template");
+const init_generated_template_1 = require("../templates/init_generated.template");
+const init_types_template_1 = require("../templates/init_types.template");
+const smd_template_1 = require("../templates/smd.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");
+class Syncer {
+    constructor(config) {
+        var _a;
+        this.apis = [];
+        this.types = {};
+        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,
+            };
+        };
+        const appRootPath = (_a = config === null || config === void 0 ? void 0 : config.appRootPath) !== null && _a !== void 0 ? _a : path_1.default.resolve(__dirname, "../../");
+        this.config = Object.assign({ appRootPath, checksumsPath: `${appRootPath}/api/.tf-checksum`, targets: ["web"] }, config);
+    }
+    static getInstance(config) {
+        var _a;
+        if (this.instance && config !== undefined) {
+            throw new Error("Syncer has already configured.");
+        }
+        return (_a = this.instance) !== null && _a !== void 0 ? _a : (this.instance = new this(config));
+    }
+    sync() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            // 트리거와 무관하게 shared 분배
+            yield Promise.all(this.config.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 (!(0, fs_extra_1.existsSync)(srcCodePath)) {
+                    return;
+                }
+                const dstCodePath = path_1.default.join(this.config.appRootPath, target, "src/services/sonamu.shared.ts");
+                const srcChecksum = yield this.getChecksumOfFile(srcCodePath);
+                const dstChecksum = yield (() => __awaiter(this, void 0, void 0, function* () {
+                    if ((0, fs_extra_1.existsSync)(dstCodePath) === false) {
+                        return "";
+                    }
+                    return this.getChecksumOfFile(dstCodePath);
+                }))();
+                if (srcChecksum === dstChecksum) {
+                    return;
+                }
+                (0, fs_extra_1.writeFileSync)(dstCodePath, (0, fs_extra_1.readFileSync)(srcCodePath));
+            })));
+            // 현재 checksums
+            const 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 = (0, lodash_1.differenceWith)(currentChecksums, previousChecksums, lodash_1.isEqual);
+            const diffFiles = diff.map((r) => r.path);
+            console.log("Changed Files: ", diffFiles);
+            // 다른 부분 찾아 액션
+            const diffGroups = (0, lodash_1.groupBy)(diffFiles, (r) => {
+                const matched = r.match(/\.(model|types|enums|smd|generated)\.[tj]s/);
+                return matched[1];
+            });
+            // 변경된 파일들을 타입별로 분리하여 각 타입별 액션 처리
+            const diffTypes = Object.keys(diffGroups);
+            // 트리거: smd
+            // 액션: 스키마 생성
+            if (diffTypes.includes("smd")) {
+                console.log("// 액션: 스키마 생성");
+                const smdIds = this.getSMDIdFromPath(diffGroups["smd"]);
+                yield this.actionGenerateSchemas(smdIds);
+            }
+            // 트리거: types, enums, generated 변경시
+            // 액션: 파일 싱크 types, enums, generated
+            if (diffTypes.includes("types") ||
+                diffTypes.includes("enums") ||
+                diffTypes.includes("generated")) {
+                console.log("// 액션: 파일 싱크 types / enums / generated");
+                const tsPaths = [
+                    ...((_a = diffGroups["types"]) !== null && _a !== void 0 ? _a : []),
+                    ...((_b = diffGroups["enums"]) !== null && _b !== void 0 ? _b : []),
+                    ...((_c = diffGroups["generated"]) !== null && _c !== void 0 ? _c : []),
+                ].map((p) => p.replace("/dist/", "/src/").replace(".js", ".ts"));
+                yield this.actionSyncFilesToTargets(tsPaths);
+            }
+            // 트리거: model
+            if (diffTypes.includes("model")) {
+                const smdIds = this.getSMDIdFromPath(diffGroups["model"]);
+                console.log("// 액션: 서비스 생성");
+                yield this.actionGenerateServices(smdIds);
+                console.log("// 액션: HTTP파일 생성");
+                yield this.actionGenerateHttps(smdIds);
+            }
+            // 저장
+            yield this.saveChecksums(currentChecksums);
+        });
+    }
+    getSMDIdFromPath(filePaths) {
+        return filePaths.map((p) => {
+            const matched = p.match(/application\/(.+)\//);
+            return (0, inflection_1.camelize)(matched[1].replace(/\-/g, "_"));
+        });
+    }
+    actionGenerateSchemas(smdIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(smdIds.map((smdId) => __awaiter(this, void 0, void 0, function* () {
+                return this.generateTemplate("generated", {
+                    smdId,
+                }, {
+                    overwrite: true,
+                });
+            }))))
+                .flat()
+                .flat();
+        });
+    }
+    actionGenerateServices(smdIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(smdIds.map((smdId) => __awaiter(this, void 0, void 0, function* () {
+                return this.generateTemplate("service", {
+                    smdId,
+                }, {
+                    overwrite: true,
+                });
+            }))))
+                .flat()
+                .flat();
+        });
+    }
+    actionGenerateHttps(smdIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(smdIds.map((smdId) => __awaiter(this, void 0, void 0, function* () {
+                return this.generateTemplate("generated_http", {
+                    smdId,
+                }, {
+                    overwrite: true,
+                });
+            }))))
+                .flat()
+                .flat();
+        });
+    }
+    copyFileWithReplaceCoreToShared(fromPath, toPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(0, fs_extra_1.existsSync)(fromPath)) {
+                return;
+            }
+            const oldFileContent = (0, fs_extra_1.readFileSync)(fromPath).toString();
+            const newFileContent = oldFileContent
+                .replace(/from "sonamu"/g, `from "../sonamu.shared"`)
+                .replace(/\/\* BEGIN- Server-side Only \*\/[\s\S]*\/\* END Server-side Only \*\/\n*/g, "");
+            return (0, fs_extra_1.writeFile)(toPath, newFileContent);
+        });
+    }
+    actionSyncFilesToTargets(tsPaths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield Promise.all(this.config.targets.map((target) => __awaiter(this, void 0, void 0, function* () {
+                return Promise.all(tsPaths.map((src) => __awaiter(this, void 0, void 0, function* () {
+                    const dst = src
+                        .replace("/api/", `/${target}/`)
+                        .replace("/application/", "/services/");
+                    const dir = (0, path_1.dirname)(dst);
+                    if (!(0, fs_extra_1.existsSync)(dir)) {
+                        (0, fs_extra_1.mkdirSync)(dir, { recursive: true });
+                    }
+                    yield this.copyFileWithReplaceCoreToShared(src, dst);
+                    return dst;
+                })));
+            })))).flat();
+        });
+    }
+    getCurrentChecksums() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const PatternGroup = {
+                /* TS 체크 */
+                types: this.config.appRootPath + "/api/src/application/**/*.types.ts",
+                enums: this.config.appRootPath + "/api/src/application/**/*.enums.ts",
+                generated: this.config.appRootPath + "/api/src/application/**/*.generated.ts",
+                /* compiled-JS 체크 */
+                model: this.config.appRootPath + "/api/dist/application/**/*.model.js",
+                smd: this.config.appRootPath + "/api/dist/application/**/*.smd.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,
+                    checksum: yield this.getChecksumOfFile(filePath),
+                };
+            })));
+            return fileChecksums;
+        });
+    }
+    getPreviousChecksums() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((0, fs_extra_1.existsSync)(this.config.checksumsPath) === false) {
+                return [];
+            }
+            const previousChecksums = (yield (0, fs_extra_1.readJSON)(this.config.checksumsPath));
+            return previousChecksums;
+        });
+    }
+    saveChecksums(checksums) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, fs_extra_1.writeJSON)(this.config.checksumsPath, checksums);
+            console.debug("checksum saved", this.config.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 = ts.createSourceFile(filePath, (0, fs_extra_1.readFileSync)(filePath).toString(), ts.ScriptTarget.Latest);
+            const methods = [];
+            let modelName = "UnknownModel";
+            let methodName = "unknownMethod";
+            const visitor = (node) => {
+                var _a;
+                if (ts.isClassDeclaration(node)) {
+                    if (node.name && ts.isIdentifier(node.name)) {
+                        modelName = node.name.escapedText.toString().replace(/Class$/, "");
+                    }
+                }
+                if (ts.isMethodDeclaration(node)) {
+                    if (ts.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);
+                        return this.resolveParamDec({
+                            name: paramDec.name,
+                            type: paramDec.type,
+                            optional: paramDec.questionToken !== undefined ||
+                                paramDec.initializer !== undefined,
+                            defaultDef,
+                        }, index);
+                    });
+                    const returnType = this.resolveTypeNode(node.type);
+                    methods.push({
+                        modelName,
+                        methodName,
+                        typeParameters,
+                        parameters,
+                        returnType,
+                    });
+                }
+                ts.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 ts.SyntaxKind.AnyKeyword:
+                return "any";
+            case ts.SyntaxKind.UnknownKeyword:
+                return "unknown";
+            case ts.SyntaxKind.StringKeyword:
+                return "string";
+            case ts.SyntaxKind.NumberKeyword:
+                return "number";
+            case ts.SyntaxKind.BooleanKeyword:
+                return "boolean";
+            case ts.SyntaxKind.UndefinedKeyword:
+                return "undefined";
+            case ts.SyntaxKind.NullKeyword:
+                return "null";
+            case ts.SyntaxKind.VoidKeyword:
+                return "void";
+            case ts.SyntaxKind.LiteralType:
+                const literal = typeNode.literal;
+                if (ts.isStringLiteral(literal)) {
+                    return {
+                        t: "string-literal",
+                        value: literal.text,
+                    };
+                }
+                else if (ts.isNumericLiteral(literal)) {
+                    return {
+                        t: "numeric-literal",
+                        value: Number(literal.text),
+                    };
+                }
+                else {
+                    if (literal.kind === ts.SyntaxKind.NullKeyword) {
+                        return "null";
+                    }
+                    else if (literal.kind === ts.SyntaxKind.UndefinedKeyword) {
+                        return "undefined";
+                    }
+                    else if (literal.kind === ts.SyntaxKind.TrueKeyword) {
+                        return "true";
+                    }
+                    else if (literal.kind === ts.SyntaxKind.FalseKeyword) {
+                        return "false";
+                    }
+                    throw new Error("알 수 없는 리터럴");
+                }
+            case ts.SyntaxKind.ArrayType:
+                const arrNode = typeNode;
+                return {
+                    t: "array",
+                    elementsType: this.resolveTypeNode(arrNode.elementType),
+                };
+            case ts.SyntaxKind.TypeLiteral:
+                const literalNode = typeNode;
+                return {
+                    t: "object",
+                    props: literalNode.members.map((member) => {
+                        if (ts.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,
+                            });
+                        }
+                    }),
+                };
+            case ts.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 ts.SyntaxKind.UnionType:
+                return {
+                    t: "union",
+                    types: typeNode.types.map((type) => this.resolveTypeNode(type)),
+                };
+            case ts.SyntaxKind.IntersectionType:
+                return {
+                    t: "intersection",
+                    types: typeNode.types.map((type) => this.resolveTypeNode(type)),
+                };
+            case ts.SyntaxKind.IndexedAccessType:
+                return {
+                    t: "indexed-access",
+                    object: this.resolveTypeNode(typeNode.objectType),
+                    index: this.resolveTypeNode(typeNode.indexType),
+                };
+            case ts.SyntaxKind.TupleType:
+                if (ts.isTupleTypeNode(typeNode)) {
+                    return {
+                        t: "tuple-type",
+                        elements: typeNode.elements.map((elem) => this.resolveTypeNode(elem)),
+                    };
+                }
+                break;
+        }
+        console.debug(typeNode);
+        throw new Error(`알 수 없는 SyntaxKind ${typeNode.kind}`);
+    }
+    printNode(node, sourceFile) {
+        if (node === undefined) {
+            return undefined;
+        }
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+        return printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+    }
+    autoloadApis(basePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathPattern = path_1.default.join(basePath, "api/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(basePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pathPattern = path_1.default.join(basePath, "api/dist/application/**/*.model.js");
+            // console.debug(chalk.yellow(`autoload:models @ ${pathPattern}`));
+            const filePaths = yield (0, utils_1.globAsync)(pathPattern);
+            const modules = yield (0, utils_1.importMultiple)(filePaths);
+            const functions = modules
+                .map(({ imported }) => Object.entries(imported))
+                .flat();
+            return Object.fromEntries(functions.filter(([name]) => name.endsWith("Model")));
+        });
+    }
+    autoloadTypes(basePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Object.keys(this.types).length > 0) {
+                return this.types;
+            }
+            const pathPatterns = [
+                path_1.default.join(basePath, "api/dist/application/**/*.types.js"),
+                path_1.default.join(basePath, "api/dist/application/**/*.enums.js"),
+                path_1.default.join(basePath, "api/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();
+            const modules = yield (0, utils_1.importMultiple)(filePaths);
+            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 === "smd") {
+            return new smd_template_1.Template__smd();
+        }
+        else if (key === "init_enums") {
+            return new init_enums_template_1.Template__init_enums();
+        }
+        else if (key === "init_types") {
+            return new init_types_template_1.Template__init_types();
+        }
+        else if (key === "init_generated") {
+            return new init_generated_template_1.Template__init_generated();
+        }
+        else if (key === "generated") {
+            return new generated_template_1.Template__generated();
+        }
+        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 (key === "service" || key === "generated_http") {
+                // service 필요 정보 (API 리스트)
+                const smd = smd_manager_1.SMDManager.get(options.smdId);
+                const modelTsPath = `${path_1.default.resolve(this.config.appRootPath, "api/src/application")}/${smd.names.fs}/${smd.names.fs}.model.ts`;
+                extra = [yield this.readApisFromFile(modelTsPath)];
+            }
+            else if (key === "view_list" || key === "model") {
+                // view_list 필요 정보 (컬럼 노드, 리스트파라미터 노드)
+                const columnsNode = yield this.getColumnsNode(options.smdId, "A");
+                const listParamsZodType = yield this.getZodTypeById(`${options.smdId}ListParams`);
+                const listParamsNode = this.zodTypeToRenderingNode(listParamsZodType);
+                extra = [columnsNode, listParamsNode];
+            }
+            else if (key === "view_form") {
+                // view_form 필요 정보 (세이브파라미터 노드)
+                const saveParamsZodType = yield this.getZodTypeById(`${options.smdId}SaveParams`);
+                const saveParamsNode = this.zodTypeToRenderingNode(saveParamsZodType);
+                extra = [saveParamsNode];
+            }
+            const rendered = template.render(options, ...extra);
+            const resolved = 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) {
+        const { target, path: filePath, body, importKeys, customHeaders } = result;
+        // import 할 대상의 대상 path 추출
+        const importDefs = importKeys
+            .reduce((r, importKey) => {
+            const modulePath = smd_manager_1.SMDManager.getModulePath(importKey);
+            let importPath = modulePath;
+            if (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 = (0, lodash_1.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 = key === "generated_http"
+            ? [header, body].join("\n\n")
+            : prettier_1.default.format([header, body].join("\n\n"), {
+                parser: "typescript",
+            });
+        return {
+            path: target + "/" + filePath,
+            code: formatted,
+        };
+    }
+    writeCodeToPath(pathAndCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { appRootPath, targets } = this.config;
+            const filePath = `${appRootPath}/${pathAndCode.path}`;
+            const dstFilePaths = (0, lodash_1.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 ((0, fs_extra_1.existsSync)(dir) === false) {
+                    (0, fs_extra_1.mkdirSync)(dir, { recursive: true });
+                }
+                (0, fs_extra_1.writeFileSync)(dstFilePath, pathAndCode.code);
+                console.log("GENERATED ", chalk_1.default.blue(dstFilePath));
+                return dstFilePath;
+            })));
+        });
+    }
+    generateTemplate(key, templateOptions, _generateOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const generateOptions = Object.assign({ overwrite: false }, _generateOptions);
+            // 키 children
+            let keys = [key];
+            if (key === "smd") {
+                keys = ["smd", "init_enums", "init_generated", "init_types"];
+            }
+            // 템플릿 렌더
+            const pathAndCodes = (yield Promise.all(keys.map((key) => __awaiter(this, void 0, void 0, function* () {
+                return this.renderTemplate(key, templateOptions);
+            })))).flat();
+            /*
+            overwrite가 true일 때
+            - 생각하지 않고 그냥 다 덮어씀
+            overwrite가 false일 때
+             - 옵션1 (현재구현): 그냥 파일 하나라도 있으면 코드 생성 안함
+             - 옵션2 : 있는 파일은 전부 그대로 두고 없는 파일만 싹 생성함
+             - 옵션3 : 메인 파일만 그대로 두고, 파생 파일은 전부 생성함 => 이게 맞지 않나?
+            */
+            let filteredPathAndCodes = [];
+            if (generateOptions.overwrite === true) {
+                filteredPathAndCodes = pathAndCodes;
+            }
+            else {
+                filteredPathAndCodes = pathAndCodes.filter((pathAndCode, index) => {
+                    if (index === 0) {
+                        const { appRootPath, targets } = this.config;
+                        const filePath = `${appRootPath}/${pathAndCode.path}`;
+                        const dstFilePaths = targets.map((target) => filePath.replace("/:target/", `/${target}/`));
+                        return dstFilePaths.every((dstPath) => (0, fs_extra_1.existsSync)(dstPath) === false);
+                    }
+                    else {
+                        return true;
+                    }
+                });
+                if (filteredPathAndCodes.length === 0) {
+                    throw new so_exceptions_1.AlreadyProcessedException("이미 경로에 모든 파일이 존재합니다.");
+                }
+            }
+            return Promise.all(filteredPathAndCodes.map((pathAndCode) => this.writeCodeToPath(pathAndCode)));
+        });
+    }
+    checkExists(smdId, enums) {
+        const keys = types_2.TemplateKey.options;
+        const names = smd_manager_1.SMDManager.getNamesFromId(smdId);
+        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}`] = (0, fs_extra_1.existsSync)(path_1.default.join(this.config.appRootPath, target, p));
+                });
+                return result;
+            }
+            const { target, path: p } = tpl.getTargetAndPath(names);
+            if (target.includes(":target")) {
+                this.config.targets.map((t) => {
+                    result[`${key}__${t}`] = (0, fs_extra_1.existsSync)(path_1.default.join(this.config.appRootPath, target.replace(":target", t), p));
+                });
+            }
+            else {
+                result[key] = (0, fs_extra_1.existsSync)(path_1.default.join(this.config.appRootPath, target, p));
+            }
+            return result;
+        }, {});
+    }
+    getZodTypeById(zodTypeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const modulePath = smd_manager_1.SMDManager.getModulePath(zodTypeId);
+            const moduleAbsPath = path_1.default.join(this.config.appRootPath, "api", "dist", "application", modulePath + ".js");
+            const importPath = "./" + path_1.default.relative(__dirname, moduleAbsPath);
+            const imported = yield Promise.resolve().then(() => __importStar(require(importPath)));
+            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) || (0, types_1.isDecimalProp)(prop)) {
+                zodType = zod_1.z.number();
+            }
+            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)) {
+                if (prop.as instanceof zod_1.z.ZodType) {
+                    zodType = prop.as;
+                }
+                else {
+                    zodType = yield this.getZodTypeById(prop.as.ref);
+                }
+            }
+            else if ((0, types_1.isUuidProp)(prop)) {
+                zodType = zod_1.z.string().uuid();
+            }
+            else if ((0, types_1.isVirtualProp)(prop)) {
+                if (prop.as instanceof zod_1.z.ZodType) {
+                    zodType = prop.as;
+                }
+                else {
+                    zodType = yield this.getZodTypeById(prop.as.ref);
+                }
+            }
+            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();
+                    throw new Error("여기를 들어온다고?");
+                }
+            }
+            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 {
+                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.ZodAny) {
+            return "string-plain";
+        }
+        else {
+            throw new Error(`타입 파싱 불가 ${key} ${zodType._def.typeName}`);
+        }
+    }
+    zodTypeToRenderingNode(zodType, baseKey = "root") {
+        const def = {
+            name: baseKey,
+            label: (0, inflection_1.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(smdId, subsetKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const smd = yield smd_manager_1.SMDManager.get(smdId);
+            const subsetA = smd.subsets[subsetKey];
+            if (subsetA === undefined) {
+                throw new so_exceptions_1.ServiceUnavailableException("SubsetA 가 없습니다.");
+            }
+            const propNodes = smd.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;
+        });
+    }
+}
+exports.Syncer = Syncer;
+//# sourceMappingURL=syncer.js.map