sonamu 0.4.14 → 0.5.1

package/dist/bin/cli.mjs

@@ -1,907 +0,0 @@
-import {
-  FixtureManager,
-  Migrator
-} from "../chunk-C3IPIF6O.mjs";
-import {
-  DB,
-  EntityManager,
-  KnexClient,
-  KyselyClient,
-  Sonamu,
-  isBelongsToOneRelationProp,
-  isEnumProp,
-  isHasManyRelationProp,
-  isManyToManyRelationProp,
-  isOneToOneRelationProp,
-  isRelationProp,
-  isVirtualProp
-} from "../chunk-FCERKIIF.mjs";
-import {
-  __dirname
-} from "../chunk-PTFDTOJU.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 inflection3 from "inflection";
-import prettier from "prettier";
-import process from "process";
-import _2 from "lodash";
-
-// 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 {
-  id;
-  parentId;
-  table;
-  title;
-  names;
-  props;
-  propsDict;
-  relations;
-  indexes;
-  subsets;
-  types = {};
-  enums = {};
-  enumLabels = {};
-  constructor({
-    id,
-    parentId,
-    table,
-    title,
-    props,
-    indexes,
-    subsets
-  }) {
-    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 {
-  SMDs = /* @__PURE__ */ new Map();
-  modulePaths = /* @__PURE__ */ new Map();
-  tableSpecs = /* @__PURE__ */ new Map();
-  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
-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"],
-      ["migrate", "status"],
-      ["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,
-      migrate_status,
-      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();
-  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_status() {
-  await setupMigrator();
-  const status = await migrator.getStatus();
-  console.log(status);
-}
-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 _db = DB.getClient("development_master");
-  const srcConn = _db.connectionInfo;
-  const targets = [
-    {
-      label: "(REMOTE) Fixture DB",
-      connKey: "fixture_remote"
-    },
-    {
-      label: "(LOCAL) Fixture DB",
-      connKey: "fixture_local"
-    },
-    {
-      label: "(LOCAL) Testing DB",
-      connKey: "test"
-    }
-  ];
-  console.log("DUMP...");
-  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;
-  const migrationsDump = `/tmp/sonamu-fixture-init-migrations-${Date.now()}.sql`;
-  execSync(
-    `mysqldump -h${srcConn.host} -P${srcConn.port} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
-  );
-  const dbClient = DB.baseConfig.client;
-  const migrationTable = DB.migrationTable;
-  const [migrations] = await _db.raw(
-    "SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = ?",
-    [srcConn.database, migrationTable]
-  );
-  if (migrations.count > 0) {
-    execSync(
-      `mysqldump -h${srcConn.host} -P${srcConn.port} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} ${migrationTable} ${migrationTable}_lock > ${migrationsDump}`
-    );
-  }
-  for await (const { label, connKey } of targets) {
-    const config = DB.connectionInfo[connKey];
-    if (label === "(LOCAL) Fixture DB" && targets.find(
-      (t) => t.label === "(REMOTE) Fixture DB" && DB.connectionInfo[t.connKey].host === config.host && DB.connectionInfo[t.connKey].database === config.database
-    )) {
-      console.log(chalk2.red(`${label}: Skipped!`));
-      continue;
-    }
-    const db = (() => {
-      if (dbClient === "knex") {
-        const config2 = _2.cloneDeep(DB.fullConfig[connKey]);
-        config2.connection.database = void 0;
-        return new KnexClient(config2);
-      } else {
-        const config2 = _2.cloneDeep(DB.fullConfig[connKey]);
-        config2.database = void 0;
-        return new KyselyClient(config2);
-      }
-    })();
-    const [row] = await db.raw(`SHOW DATABASES LIKE "${config.database}"`);
-    if (row) {
-      console.log(
-        chalk2.yellow(`${label}: Database "${config.database}" Already exists`)
-      );
-      await db.destroy();
-      continue;
-    }
-    console.log(`SYNC to ${label}...`);
-    const mysqlCmd = `mysql -h${config.host} -P${srcConn.port} -u${config.user} -p${config.password}`;
-    execSync(`${mysqlCmd} -e 'DROP DATABASE IF EXISTS \`${config.database}\`'`);
-    execSync(`${mysqlCmd} -e 'CREATE DATABASE \`${config.database}\`'`);
-    execSync(`${mysqlCmd} ${config.database} < ${dumpFilename}`);
-    if (fs2.existsSync(migrationsDump)) {
-      execSync(`${mysqlCmd} ${config.database} < ${migrationsDump}`);
-    }
-    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