sonamu 0.2.38 → 0.2.40

package/dist/bin/cli.mjs

@@ -0,0 +1,887 @@
+const require = (await import('module')).createRequire(import.meta.url);
+import {
+  BaseModel,
+  EntityManager,
+  FixtureManager,
+  Migrator,
+  Sonamu,
+  isBelongsToOneRelationProp,
+  isEnumProp,
+  isHasManyRelationProp,
+  isManyToManyRelationProp,
+  isOneToOneRelationProp,
+  isRelationProp,
+  isVirtualProp
+} from "../chunk-OTFO46SP.mjs";
+import {
+  __dirname
+} from "../chunk-JXJTFHF7.mjs";
+
+// src/bin/cli.ts
+import chalk2 from "chalk";
+import dotenv from "dotenv";
+import path3 from "path";
+import { tsicli } from "tsicli";
+import { execSync } from "child_process";
+import fs2 from "fs-extra";
+import knex from "knex";
+import inflection3 from "inflection";
+import prettier from "prettier";
+
+// src/smd/smd-manager.ts
+import chalk from "chalk";
+import glob from "glob";
+import inflection2 from "inflection";
+import path2 from "path";
+
+// src/smd/smd.ts
+import _ from "lodash";
+import inflection from "inflection";
+import path from "path";
+import fs from "fs-extra";
+var SMD = class {
+  constructor({
+    id,
+    parentId,
+    table,
+    title,
+    props,
+    indexes,
+    subsets
+  }) {
+    this.types = {};
+    this.enums = {};
+    this.enumLabels = {};
+    this.id = id;
+    this.parentId = parentId;
+    this.title = title ?? this.id;
+    this.table = table ?? inflection.underscore(inflection.pluralize(id));
+    if (props) {
+      this.props = props.map((prop) => {
+        if (isEnumProp(prop)) {
+          if (prop.id.includes("$Model")) {
+            prop.id = prop.id.replace("$Model", id);
+          }
+        }
+        return prop;
+      });
+      this.propsDict = props.reduce((result, prop) => {
+        return {
+          ...result,
+          [prop.name]: prop
+        };
+      }, {});
+      this.relations = props.filter((prop) => isRelationProp(prop)).reduce((result, prop) => {
+        return {
+          ...result,
+          [prop.name]: prop
+        };
+      }, {});
+    } else {
+      this.props = [];
+      this.propsDict = {};
+      this.relations = {};
+    }
+    this.indexes = indexes ?? [];
+    this.subsets = subsets ?? {};
+    this.names = {
+      fs: parentId === void 0 ? inflection.dasherize(inflection.underscore(id)).toLowerCase() : inflection.dasherize(parentId).toLowerCase(),
+      module: id
+    };
+    this.registerModulePaths();
+    this.registerTableSpecs();
+  }
+  /*
+    subset SELECT/JOIN/LOADER 결과 리턴
+  */
+  getSubsetQuery(subsetKey) {
+    const subset = this.subsets[subsetKey];
+    const result = this.resolveSubsetQuery("", subset);
+    return result;
+  }
+  /*
+   */
+  resolveSubsetQuery(prefix, fields, isAlreadyOuterJoined = false) {
+    prefix = prefix.replace(/\./g, "__");
+    const subsetGroup = _.groupBy(fields, (field) => {
+      if (field.includes(".")) {
+        const [rel] = field.split(".");
+        return rel;
+      } else {
+        return "";
+      }
+    });
+    const result = Object.keys(subsetGroup).reduce(
+      (r, groupKey) => {
+        const fields2 = subsetGroup[groupKey];
+        if (groupKey === "") {
+          const realFields = fields2.filter(
+            (field) => !isVirtualProp(this.propsDict[field])
+          );
+          const virtualFields = fields2.filter(
+            (field) => isVirtualProp(this.propsDict[field])
+          );
+          if (prefix === "") {
+            r.select = r.select.concat(
+              realFields.map((field) => `${this.table}.${field}`)
+            );
+            r.virtual = r.virtual.concat(virtualFields);
+          } else {
+            r.select = r.select.concat(
+              realFields.map(
+                (field) => `${prefix}.${field} as ${prefix}__${field}`
+              )
+            );
+          }
+          return r;
+        }
+        const relation = this.relations[groupKey];
+        if (relation === void 0) {
+          throw new Error(`\uC874\uC7AC\uD558\uC9C0 \uC54A\uB294 relation \uCC38\uC870 ${groupKey}`);
+        }
+        const relSMD = SMDManager.get(relation.with);
+        if (isOneToOneRelationProp(relation) || isBelongsToOneRelationProp(relation)) {
+          const relFields = fields2.map(
+            (field) => field.split(".").slice(1).join(".")
+          );
+          if (relFields.length === 1 && relFields[0] === "id") {
+            if (prefix === "") {
+              r.select = r.select.concat(`${this.table}.${groupKey}_id`);
+            } else {
+              r.select = r.select.concat(
+                `${prefix}.${groupKey}_id as ${prefix}__${groupKey}_id`
+              );
+            }
+            return r;
+          }
+          const innerOrOuter = (() => {
+            if (isAlreadyOuterJoined) {
+              return "outer";
+            }
+            if (isOneToOneRelationProp(relation)) {
+              if (relation.hasJoinColumn === true && (relation.nullable ?? false) === false) {
+                return "inner";
+              } else {
+                return "outer";
+              }
+            } else {
+              if (relation.nullable) {
+                return "outer";
+              } else {
+                return "inner";
+              }
+            }
+          })();
+          const relSubsetQuery = relSMD.resolveSubsetQuery(
+            `${prefix !== "" ? prefix + "." : ""}${groupKey}`,
+            relFields,
+            innerOrOuter === "outer"
+          );
+          r.select = r.select.concat(relSubsetQuery.select);
+          r.virtual = r.virtual.concat(relSubsetQuery.virtual);
+          const joinAs = prefix === "" ? groupKey : prefix + "__" + groupKey;
+          const fromTable = prefix === "" ? this.table : prefix;
+          let joinClause;
+          if (relation.customJoinClause) {
+            joinClause = {
+              custom: relation.customJoinClause
+            };
+          } else {
+            let from, to;
+            if (isOneToOneRelationProp(relation)) {
+              if (relation.hasJoinColumn) {
+                from = `${fromTable}.${relation.name}_id`;
+                to = `${joinAs}.id`;
+              } else {
+                from = `${fromTable}.id`;
+                to = `${joinAs}.${inflection.underscore(
+                  this.names.fs.replace(/\-/g, "_")
+                )}_id`;
+              }
+            } else {
+              from = `${fromTable}.${relation.name}_id`;
+              to = `${joinAs}.id`;
+            }
+            joinClause = {
+              from,
+              to
+            };
+          }
+          r.joins.push({
+            as: joinAs,
+            join: innerOrOuter,
+            table: relSMD.table,
+            ...joinClause
+          });
+          if (relSubsetQuery.loaders.length > 0) {
+            const convertedLoaders = relSubsetQuery.loaders.map((loader) => {
+              const newAs = [groupKey, loader.as].join("__");
+              return {
+                as: newAs,
+                table: loader.table,
+                manyJoin: loader.manyJoin,
+                oneJoins: loader.oneJoins,
+                select: loader.select
+              };
+            });
+            r.loaders = [...r.loaders, ...convertedLoaders];
+          }
+          r.joins = r.joins.concat(relSubsetQuery.joins);
+        } else if (isHasManyRelationProp(relation) || isManyToManyRelationProp(relation)) {
+          const relFields = fields2.map(
+            (field) => field.split(".").slice(1).join(".")
+          );
+          const relSubsetQuery = relSMD.resolveSubsetQuery("", relFields);
+          let manyJoin;
+          if (isHasManyRelationProp(relation)) {
+            manyJoin = {
+              fromTable: this.table,
+              fromCol: "id",
+              idField: prefix === "" ? `id` : `${prefix}__id`,
+              toTable: relSMD.table,
+              toCol: relation.joinColumn
+            };
+          } else if (isManyToManyRelationProp(relation)) {
+            const [table1, table2] = relation.joinTable.split("__");
+            manyJoin = {
+              fromTable: this.table,
+              fromCol: "id",
+              idField: prefix === "" ? `id` : `${prefix}__id`,
+              through: {
+                table: relation.joinTable,
+                fromCol: `${inflection.singularize(table1)}_id`,
+                toCol: `${inflection.singularize(table2)}_id`
+              },
+              toTable: relSMD.table,
+              toCol: "id"
+            };
+          } else {
+            throw new Error();
+          }
+          r.loaders.push({
+            as: groupKey,
+            table: relSMD.table,
+            manyJoin,
+            oneJoins: relSubsetQuery.joins,
+            select: relSubsetQuery.select,
+            loaders: relSubsetQuery.loaders
+          });
+        }
+        return r;
+      },
+      {
+        select: [],
+        virtual: [],
+        joins: [],
+        loaders: []
+      }
+    );
+    return result;
+  }
+  /*
+    FieldExpr[] 을 SMDPropNode[] 로 변환
+  */
+  fieldExprsToPropNodes(fieldExprs, smd = this) {
+    const groups = fieldExprs.reduce(
+      (result, fieldExpr) => {
+        let key, value, elseExpr;
+        if (fieldExpr.includes(".")) {
+          [key, ...elseExpr] = fieldExpr.split(".");
+          value = elseExpr.join(".");
+        } else {
+          key = "";
+          value = fieldExpr;
+        }
+        result[key] = (result[key] ?? []).concat(value);
+        return result;
+      },
+      {}
+    );
+    return Object.keys(groups).map((key) => {
+      const group = groups[key];
+      if (key === "") {
+        return group.map((propName) => {
+          if (propName === "uuid") {
+            return {
+              nodeType: "plain",
+              prop: {
+                type: "string",
+                name: "uuid",
+                length: 128
+              },
+              children: []
+            };
+          }
+          const prop2 = smd.propsDict[propName];
+          if (prop2 === void 0) {
+            throw new Error(`${this.id} -- \uC798\uBABB\uB41C FieldExpr ${propName}`);
+          }
+          return {
+            nodeType: "plain",
+            prop: prop2,
+            children: []
+          };
+        });
+      }
+      const prop = smd.propsDict[key];
+      if (!isRelationProp(prop)) {
+        throw new Error(`\uC798\uBABB\uB41C FieldExpr ${key}.${group[0]}`);
+      }
+      const relSMD = SMDManager.get(prop.with);
+      if (isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop)) {
+        if (group.length == 1 && (group[0] === "id" || group[0] == "id?")) {
+          const idProp = relSMD.propsDict.id;
+          return {
+            nodeType: "plain",
+            prop: {
+              ...idProp,
+              name: key + "_id",
+              nullable: prop.nullable
+            },
+            children: []
+          };
+        }
+      }
+      const children = this.fieldExprsToPropNodes(group, relSMD);
+      const nodeType = isBelongsToOneRelationProp(prop) || isOneToOneRelationProp(prop) ? "object" : "array";
+      return {
+        prop,
+        children,
+        nodeType
+      };
+    }).flat();
+  }
+  getFieldExprs(prefix = "", maxDepth = 3, froms = []) {
+    return this.props.map((prop) => {
+      const propName = [prefix, prop.name].filter((v) => v !== "").join(".");
+      if (propName === prefix) {
+        return null;
+      }
+      if (isRelationProp(prop)) {
+        if (maxDepth < 0) {
+          return null;
+        }
+        if (froms.includes(prop.with)) {
+          return null;
+        }
+        const relMd = SMDManager.get(prop.with);
+        return relMd.getFieldExprs(propName, maxDepth - 1, [
+          ...froms,
+          this.id
+        ]);
+      }
+      return propName;
+    }).flat().filter((f) => f !== null);
+  }
+  registerModulePaths() {
+    const basePath = `${this.names.fs}`;
+    SMDManager.setModulePath(
+      `${this.id}BaseSchema`,
+      `${basePath}/${this.names.fs}.generated`
+    );
+    if (Object.keys(this.subsets).length > 0) {
+      SMDManager.setModulePath(
+        `${this.id}SubsetKey`,
+        `${basePath}/${this.names.fs}.generated`
+      );
+      SMDManager.setModulePath(
+        `${this.id}SubsetMapping`,
+        `${basePath}/${this.names.fs}.generated`
+      );
+      Object.keys(this.subsets).map((subsetKey) => {
+        SMDManager.setModulePath(
+          `${this.id}Subset${subsetKey.toUpperCase()}`,
+          `${basePath}/${this.names.fs}.generated`
+        );
+      });
+    }
+    const typesModulePath = `${basePath}/${this.names.fs}.types`;
+    const typesFileDistPath = path.join(
+      Sonamu.apiRootPath,
+      `dist/application/${typesModulePath}.js`
+    );
+    if (fs.existsSync(typesFileDistPath)) {
+      const importPath = path.relative(__dirname, typesFileDistPath);
+      import(importPath).then((t) => {
+        this.types = Object.keys(t).reduce((result, key) => {
+          SMDManager.setModulePath(key, typesModulePath);
+          return {
+            ...result,
+            [key]: t[key]
+          };
+        }, {});
+      });
+    }
+    const enumsModulePath = `${basePath}/${this.names.fs}.enums`;
+    const enumsFileDistPath = path.join(
+      Sonamu.apiRootPath,
+      `/dist/application/${enumsModulePath}.js`
+    );
+    if (fs.existsSync(enumsFileDistPath)) {
+      const importPath = path.relative(__dirname, enumsFileDistPath);
+      import(importPath).then((t) => {
+        this.enums = Object.keys(t).reduce((result, key) => {
+          SMDManager.setModulePath(key, enumsModulePath);
+          if (key === inflection.underscore(this.id).toUpperCase()) {
+            this.enumLabels = t[key];
+          }
+          return {
+            ...result,
+            [key]: t[key]
+          };
+        }, {});
+      });
+    }
+  }
+  registerTableSpecs() {
+    const uniqueColumns = _.uniq(
+      this.indexes.filter((idx) => idx.type === "unique").map((idx) => idx.columns).flat()
+    );
+    SMDManager.setTableSpec({
+      name: this.table,
+      uniqueColumns
+    });
+  }
+};
+
+// src/smd/smd-manager.ts
+var SMDManagerClass = class {
+  constructor() {
+    this.SMDs = /* @__PURE__ */ new Map();
+    this.modulePaths = /* @__PURE__ */ new Map();
+    this.tableSpecs = /* @__PURE__ */ new Map();
+    this.isAutoloaded = false;
+  }
+  // 경로 전달받아 모든 SMD 파일 로드
+  async autoload(doSilent = false) {
+    if (this.isAutoloaded) {
+      return;
+    }
+    const pathPattern = path2.join(
+      Sonamu.apiRootPath,
+      "/dist/application/**/*.smd.js"
+    );
+    !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
+    return new Promise((resolve) => {
+      glob.glob(path2.resolve(pathPattern), (_err, files) => {
+        const importPaths = files.map(
+          (filePath) => path2.relative(__dirname, filePath)
+        );
+        Promise.all(
+          importPaths.map(async (importPath) => {
+            const imported = await import(importPath);
+            Object.values(imported).map(
+              (smdInput) => this.register(smdInput)
+            );
+            return imported;
+          })
+        ).then(() => {
+          resolve("ok");
+          this.isAutoloaded = true;
+        });
+      });
+    });
+  }
+  register(smdInput) {
+    const smd = new SMD(smdInput);
+    this.SMDs.set(smdInput.id, smd);
+  }
+  get(smdId) {
+    const smd = this.SMDs.get(smdId);
+    if (smd === void 0) {
+      throw new Error(`\uC874\uC7AC\uD558\uC9C0 \uC54A\uB294 SMD \uC694\uCCAD ${smdId}`);
+    }
+    return smd;
+  }
+  exists(smdId) {
+    const smd = this.SMDs.get(smdId);
+    return smd !== void 0;
+  }
+  getAllIds() {
+    return Array.from(SMDManager.SMDs.keys());
+  }
+  getAllParentIds() {
+    return this.getAllIds().filter((smdId) => {
+      const smd = this.get(smdId);
+      return smd.parentId === void 0;
+    });
+  }
+  getChildrenIds(parentId) {
+    return this.getAllIds().filter((smdId) => {
+      const smd = this.get(smdId);
+      return smd.parentId === parentId;
+    });
+  }
+  setModulePath(key, modulePath) {
+    this.modulePaths.set(key, modulePath);
+  }
+  getModulePath(key) {
+    const modulePath = this.modulePaths.get(key);
+    if (modulePath === void 0) {
+      throw new Error(`\uC874\uC7AC\uD558\uC9C0 \uC54A\uB294 \uBAA8\uB4C8 \uD328\uC2A4 \uC694\uCCAD ${key}`);
+    }
+    return modulePath;
+  }
+  setTableSpec(tableSpec) {
+    this.tableSpecs.set(tableSpec.name, tableSpec);
+  }
+  getTableSpec(key) {
+    const tableSpec = this.tableSpecs.get(key);
+    if (tableSpec === void 0) {
+      throw new Error(`\uC874\uC7AC\uD558\uC9C0 \uC54A\uB294 \uD14C\uC774\uBE14 \uC2A4\uD399 \uC694\uCCAD ${key}`);
+    }
+    return tableSpec;
+  }
+  getNamesFromId(smdId) {
+    const pluralized = inflection2.pluralize(smdId) === smdId ? `${smdId}List` : inflection2.pluralize(smdId);
+    return {
+      fs: inflection2.dasherize(inflection2.underscore(smdId)).toLowerCase(),
+      fsPlural: inflection2.dasherize(inflection2.underscore(pluralized)).toLowerCase(),
+      camel: inflection2.camelize(smdId, true),
+      camelPlural: inflection2.camelize(pluralized, true),
+      capital: smdId,
+      capitalPlural: pluralized,
+      upper: smdId.toUpperCase(),
+      constant: inflection2.underscore(smdId).toUpperCase()
+    };
+  }
+};
+var SMDManager = new SMDManagerClass();
+
+// src/bin/cli.ts
+import process from "process";
+console.log(chalk2.bgBlue(`BEGIN ${/* @__PURE__ */ new Date()}`));
+dotenv.config();
+var migrator;
+async function bootstrap() {
+  await Sonamu.init(false, false);
+  await tsicli(process.argv, {
+    types: {
+      "#entityId": {
+        type: "autocomplete",
+        name: "#entityId",
+        message: "Please input #entityId",
+        choices: EntityManager.getAllParentIds().map((entityId) => ({
+          title: entityId,
+          value: entityId
+        }))
+      },
+      "#recordIds": "number[]",
+      "#name": "string"
+    },
+    args: [
+      ["fixture", "init"],
+      ["fixture", "import", "#entityId", "#recordIds"],
+      ["fixture", "sync"],
+      ["migrate", "run"],
+      ["migrate", "check"],
+      ["migrate", "rollback"],
+      ["migrate", "reset"],
+      ["migrate", "clear"],
+      ["stub", "practice", "#name"],
+      ["stub", "entity", "#name"],
+      ["scaffold", "model", "#entityId"],
+      ["scaffold", "model_test", "#entityId"],
+      ["scaffold", "view_list", "#entityId"],
+      ["scaffold", "view_form", "#entityId"],
+      ["ui"],
+      ["smd_migration"]
+    ],
+    runners: {
+      migrate_run,
+      migrate_check,
+      migrate_rollback,
+      migrate_clear,
+      migrate_reset,
+      fixture_init,
+      fixture_import,
+      fixture_sync,
+      stub_practice,
+      stub_entity,
+      scaffold_model,
+      scaffold_model_test,
+      ui,
+      // scaffold_view_list,
+      // scaffold_view_form,
+      smd_migration
+    }
+  });
+}
+bootstrap().finally(async () => {
+  if (migrator) {
+    await migrator.destroy();
+  }
+  await FixtureManager.destory();
+  await BaseModel.destroy();
+  console.log(chalk2.bgBlue(`END ${/* @__PURE__ */ new Date()}
+`));
+});
+async function setupMigrator() {
+  migrator = new Migrator({
+    mode: "dev"
+  });
+}
+async function setupFixtureManager() {
+  FixtureManager.init();
+}
+async function migrate_run() {
+  await setupMigrator();
+  await migrator.cleanUpDist();
+  await migrator.run();
+}
+async function migrate_check() {
+  await setupMigrator();
+  await migrator.cleanUpDist();
+  await migrator.check();
+}
+async function migrate_rollback() {
+  await setupMigrator();
+  await migrator.rollback();
+}
+async function migrate_clear() {
+  await setupMigrator();
+  await migrator.clearPendingList();
+}
+async function migrate_reset() {
+  await setupMigrator();
+  await migrator.resetAll();
+}
+async function fixture_init() {
+  const srcConfig = Sonamu.dbConfig.development_master;
+  const targets = [
+    {
+      label: "(REMOTE) Fixture DB",
+      config: Sonamu.dbConfig.fixture_remote
+    },
+    {
+      label: "(LOCAL) Fixture DB",
+      config: Sonamu.dbConfig.fixture_local,
+      toSkip: (() => {
+        const remoteConn = Sonamu.dbConfig.fixture_remote.connection;
+        const localConn = Sonamu.dbConfig.fixture_local.connection;
+        return remoteConn.host === localConn.host && remoteConn.database === localConn.database;
+      })()
+    },
+    {
+      label: "(LOCAL) Testing DB",
+      config: Sonamu.dbConfig.test
+    }
+  ];
+  console.log("DUMP...");
+  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;
+  const srcConn = srcConfig.connection;
+  execSync(
+    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
+  );
+  for await (const { label, config, toSkip } of targets) {
+    const conn = config.connection;
+    if (toSkip === true) {
+      console.log(chalk2.red(`${label}: Skipped!`));
+      continue;
+    }
+    const db = knex({
+      ...config,
+      connection: {
+        ...config.connection ?? {},
+        database: void 0
+      }
+    });
+    const [[row]] = await db.raw(`SHOW DATABASES LIKE "${conn.database}"`);
+    if (row) {
+      console.log(
+        chalk2.yellow(`${label}: Database "${conn.database}" Already exists`)
+      );
+      await db.destroy();
+      continue;
+    }
+    console.log(`SYNC to ${label}...`);
+    const mysqlCmd = `mysql -h${conn.host} -u${conn.user} -p${conn.password}`;
+    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \`${conn.database}\`'`);
+    execSync(`${mysqlCmd} -e 'CREATE DATABASE \`${conn.database}\`'`);
+    execSync(`${mysqlCmd} ${conn.database} < ${dumpFilename}`);
+    await Promise.all(
+      ["knex_migrations", "knex_migrations_lock"].map(async (tableName) => {
+        const [table] = await db.raw(
+          `SHOW TABLES FROM \`${srcConn.database}\` LIKE '${tableName}'`
+        );
+        if (table?.length) {
+          await db.raw(
+            `INSERT INTO \`${conn.database}\`.${tableName}
+          SELECT * FROM \`${srcConn.database}\`.${tableName}`
+          );
+        }
+      })
+    );
+    await db.destroy();
+  }
+}
+async function fixture_import(entityId, recordIds) {
+  await setupFixtureManager();
+  await FixtureManager.importFixture(entityId, recordIds);
+  await FixtureManager.sync();
+}
+async function fixture_sync() {
+  await setupFixtureManager();
+  await FixtureManager.sync();
+}
+async function stub_practice(name) {
+  const practiceDir = path3.join(Sonamu.apiRootPath, "src", "practices");
+  const fileNames = fs2.readdirSync(practiceDir);
+  const maxSeqNo = (() => {
+    if (fs2.existsSync(practiceDir) === false) {
+      fs2.mkdirSync(practiceDir, { recursive: true });
+    }
+    const filteredSeqs = fileNames.filter(
+      (fileName2) => fileName2.startsWith("p") && fileName2.endsWith(".ts")
+    ).map((fileName2) => {
+      const [, seqNo] = fileName2.match(/^p([0-9]+)\-/) ?? ["0", "0"];
+      return parseInt(seqNo);
+    }).sort((a, b) => b - a);
+    if (filteredSeqs.length > 0) {
+      return filteredSeqs[0];
+    }
+    return 0;
+  })();
+  const currentSeqNo = maxSeqNo + 1;
+  const fileName = `p${currentSeqNo}-${name}.ts`;
+  const dstPath = path3.join(practiceDir, fileName);
+  const code = [
+    `import { BaseModel } from "sonamu";`,
+    "",
+    `console.clear();`,
+    `console.log("${fileName}");`,
+    "",
+    `async function bootstrap() {`,
+    ` // TODO`,
+    `}`,
+    `bootstrap().finally(async () => {`,
+    `await BaseModel.destroy();`,
+    `});`
+  ].join("\n");
+  fs2.writeFileSync(dstPath, code);
+  execSync(`code ${dstPath}`);
+  const runCode = `yarn node -r source-map-support/register dist/practices/${fileName.replace(
+    ".ts",
+    ".js"
+  )}`;
+  console.log(`${chalk2.blue(runCode)} copied to clipboard.`);
+  execSync(`echo "${runCode}" | pbcopy`);
+}
+async function stub_entity(entityId) {
+  await Sonamu.syncer.createEntity(entityId);
+}
+async function scaffold_model(entityId) {
+  await Sonamu.syncer.generateTemplate("model", {
+    entityId
+  });
+}
+async function scaffold_model_test(entityId) {
+  await Sonamu.syncer.generateTemplate("model_test", {
+    entityId
+  });
+}
+async function ui() {
+  try {
+    const sonamuUI = await import("@sonamu-kit/ui");
+    sonamuUI.startServers(Sonamu.apiRootPath);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("isn't declared")) {
+      console.log(`You need to install ${chalk2.blue(`@sonamu-kit/ui`)} first.`);
+      return;
+    }
+    throw e;
+  }
+}
+async function smd_migration() {
+  await SMDManager.autoload();
+  const smdIds = SMDManager.getAllIds();
+  function enumLabelsToEntityEnums(entityId, enumLabels) {
+    return Object.fromEntries(
+      Object.entries(enumLabels).map(([enumLabelName, enumLabel]) => {
+        const enumName = entityId + inflection3.camelize(enumLabelName.toLowerCase(), false);
+        return [
+          enumName,
+          Object.fromEntries(
+            Object.entries(enumLabel).map(([name, { ko }]) => [name, ko])
+          )
+        ];
+      })
+    );
+  }
+  for await (const smdId of smdIds) {
+    const smd = SMDManager.get(smdId);
+    const entityJson = {
+      id: smd.id,
+      ...smd.parentId && { parentId: smd.parentId },
+      title: smd.title,
+      props: smd.props,
+      indexes: smd.indexes,
+      subsets: smd.subsets,
+      enums: enumLabelsToEntityEnums(smd.id, smd.enumLabels)
+    };
+    const parentNames = SMDManager.getNamesFromId(smd.parentId ?? smd.id);
+    const names = SMDManager.getNamesFromId(smd.id);
+    const dstPath = path3.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.entity.json`
+    );
+    const formatted = await prettier.format(JSON.stringify(entityJson), {
+      parser: "json"
+    });
+    fs2.writeFileSync(dstPath, formatted);
+    console.log(chalk2.blue(`CREATED: ${dstPath}`));
+    const srcSmdPath = path3.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.smd.ts`
+    );
+    const dstSmdPath = srcSmdPath.replace("/src/", "/dist/").replace(/\.ts$/, ".js");
+    const srcEnumsPath = path3.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.enums.ts`
+    );
+    const dstEnumsPath = srcEnumsPath.replace("/src/", "/dist/").replace(/\.ts$/, ".js");
+    const srcGeneratedPath = path3.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.generated.ts`
+    );
+    const dstGeneratedPath = srcGeneratedPath.replace("/src/", "/dist/").replace(/\.ts$/, ".js");
+    [
+      srcSmdPath,
+      dstSmdPath,
+      srcEnumsPath,
+      dstEnumsPath,
+      ...Sonamu.config.sync.targets.map(
+        (target) => srcEnumsPath.replace(Sonamu.apiRootPath, path3.join(Sonamu.appRootPath, target)).replace("/src/application/", "/src/services/")
+      ),
+      srcGeneratedPath,
+      dstGeneratedPath
+    ].map((p) => {
+      if (fs2.existsSync(p) === false) {
+        console.log(chalk2.yellow(`NOT FOUND: ${p}`));
+        return;
+      }
+      fs2.unlinkSync(p);
+      console.log(chalk2.red(`DELETED: ${p}`));
+    });
+  }
+  console.log("Entity\uB85C \uB2E4\uC2DC \uB85C\uB4DC\uD569\uB2C8\uB2E4.");
+  EntityManager.isAutoloaded = false;
+  await EntityManager.autoload();
+  const entityIds = EntityManager.getAllParentIds();
+  for await (const entityId of entityIds) {
+    await Sonamu.syncer.generateTemplate("generated", { entityId });
+  }
+}
+//# sourceMappingURL=cli.mjs.map