sonamu 0.0.7 → 0.0.9

package/src/bin/cli.ts

@@ -12,29 +12,60 @@ import { SMDManager } from "../smd/smd-manager";
 import { Migrator } from "../smd/migrator";
 import { Syncer } from "../syncer/syncer";
 import { FixtureManager } from "../testing/fixture-manager";
+import { tsicli } from "tsicli";
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { Sonamu } from "../api";
 
 let migrator: Migrator;
 let fixtureManager: FixtureManager;
 
 async function bootstrap() {
-  // appRootPath 셋업
-  const appRootPath = path.resolve(process.cwd(), "..");
-  Syncer.getInstance({
-    appRootPath,
+  await Sonamu.init();
+
+  await tsicli(process.argv, {
+    types: {
+      "#smdId": {
+        type: "autocomplete",
+        name: "#smdId",
+        message: "Please input #smdId",
+        choices: SMDManager.getAllParentIds().map((smdId) => ({
+          title: smdId,
+          value: smdId,
+        })),
+      },
+      "#recordIds": "number[]",
+      "#name": "string",
+    },
+    args: [
+      ["fixture", "import", "#smdId", "#recordIds"],
+      ["fixture", "sync"],
+      ["migrate", "run"],
+      ["migrate", "rollback"],
+      ["migrate", "reset"],
+      ["migrate", "clear"],
+      ["stub", "practice", "#name"],
+      ["stub", "smd", "#name"],
+      ["scaffold", "model", "#smdId"],
+      ["scaffold", "model_test", "#smdId"],
+      ["scaffold", "view_list", "#smdId"],
+      ["scaffold", "view_form", "#smdId"],
+    ],
+    runners: {
+      migrate_run,
+      migrate_rollback,
+      migrate_clear,
+      migrate_reset,
+      fixture_import,
+      fixture_sync,
+      stub_practice,
+      stub_smd,
+      scaffold_model,
+      scaffold_model_test,
+      // scaffold_view_list,
+      // scaffold_view_form,
+    },
   });
-  await DB.readKnexfile(appRootPath);
-
-  const [_0, _1, action, ...args] = process.argv;
-  switch (action) {
-    case "migrate":
-      await migrate(args[0] as MigrateSubAction);
-      break;
-    case "fixture":
-      await fixture(args[0] as FixtureSubAction, args.slice(1));
-      break;
-    default:
-      throw new Error(`Unknown action ${action}`);
-  }
 }
 bootstrap().finally(async () => {
   if (migrator) {
@@ -49,67 +80,125 @@ bootstrap().finally(async () => {
   console.log(chalk.bgBlue(`END ${new Date()}\n`));
 });
 
-type MigrateSubAction = "run" | "rollback" | "reset" | "clear";
-async function migrate(subAction: MigrateSubAction) {
-  await SMDManager.autoload();
-
+async function setupMigrator() {
   // migrator
   migrator = new Migrator({
-    appRootPath: Syncer.getInstance().config.appRootPath,
     knexfile: DB.getKnexfile(),
     mode: "dev",
   });
+}
 
-  switch (subAction) {
-    case "run":
-      await migrator.cleanUpDist();
-      await migrator.run();
-      break;
-    case "rollback":
-      await migrator.rollback();
-      break;
-    case "clear":
-      await migrator.clearPendingList();
-      break;
-    case "reset":
-      await migrator.resetAll();
-      break;
-    default:
-      throw new Error(`Unknown subAction - ${subAction}`);
-  }
+async function setupFixtureManager() {
+  fixtureManager = new FixtureManager();
 }
 
-type FixtureSubAction = "import" | "sync";
-async function fixture(subAction: FixtureSubAction, extras?: string[]) {
-  await SMDManager.autoload();
+async function migrate_run() {
+  await setupMigrator();
 
-  fixtureManager = new FixtureManager();
+  await migrator.cleanUpDist();
+  await migrator.run();
+}
 
-  switch (subAction) {
-    case "import":
-      if (!extras || Array.isArray(extras) === false || extras.length !== 2) {
-        throw new Error("Import 대상 smdId와 id가 필요합니다.");
-      }
-      const [smdId, idsString] = extras;
-      let ids: number[] = [];
-      if (idsString.includes(",")) {
-        ids = idsString
-          .split(",")
-          .map((idString) => Number(idString))
-          .filter((id) => Number.isNaN(id) === false);
-      } else {
-        ids = [Number(idsString)];
-      }
-      if (smdId === undefined || idsString === undefined || ids.length === 0) {
-        throw new Error("잘못된 입력");
-      }
-      await fixtureManager.importFixture(smdId, ids);
-      await fixtureManager.sync();
-      break;
-    case "sync":
-      await fixtureManager.sync();
-      break;
-    default:
-      throw new Error(`Unknown subAction - ${subAction}`);
-  }
+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_import(smdId: string, recordIds: number[]) {
+  await setupFixtureManager();
+
+  await fixtureManager.importFixture(smdId, recordIds);
+  await fixtureManager.sync();
+}
+
+async function fixture_sync() {
+  await setupFixtureManager();
+
+  await fixtureManager.sync();
+}
+
+async function stub_practice(name: string) {
+  const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
+  const fileNames = readdirSync(practiceDir);
+
+  const maxSeqNo = (() => {
+    if (existsSync(practiceDir) === false) {
+      mkdirSync(practiceDir, { recursive: true });
+    }
+
+    const filteredSeqs = fileNames
+      .filter(
+        (fileName) => fileName.startsWith("p") && fileName.endsWith(".ts")
+      )
+      .map((fileName) => {
+        const [, seqNo] = fileName.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 = path.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");
+  writeFileSync(dstPath, code);
+
+  execSync(`code ${dstPath}`);
+
+  const runCode = `yarn node -r source-map-support/register dist/practices/${fileName.replace(
+    ".ts",
+    ".js"
+  )}`;
+  console.log(`${chalk.blue(runCode)} copied to clipboard.`);
+  execSync(`echo "${runCode}" | pbcopy`);
+}
+
+async function stub_smd(name: string) {
+  await Sonamu.syncer.generateTemplate("smd", {
+    smdId: name,
+  });
+}
+
+async function scaffold_model(smdId: string) {
+  await Sonamu.syncer.generateTemplate("model", {
+    smdId,
+  });
+}
+
+async function scaffold_model_test(smdId: string) {
+  await Sonamu.syncer.generateTemplate("model_test", {
+    smdId,
+  });
 }

package/src/database/db.ts

@@ -1,8 +1,8 @@
 export type DBPreset = "w" | "r";
 import knex, { Knex } from "knex";
 import path from "path";
+import { Sonamu } from "../api";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions";
-import { findAppRootPath } from "../utils/utils";
 
 export type SonamuDBConfig = {
   development_master: Knex.Config;
@@ -17,36 +17,24 @@ export type SonamuDBConfig = {
 class DBClass {
   private wdb?: Knex;
   private rdb?: Knex;
-  private knexfile?: SonamuDBConfig;
 
-  async readKnexfile(_appRootPath?: string): Promise<SonamuDBConfig> {
-    if (this.knexfile) {
-      return this.knexfile;
-    }
-
-    const appRootPath = _appRootPath ?? (await findAppRootPath());
-    const configPath: string = path.join(appRootPath, "/api/dist/configs/db");
+  async readKnexfile(): Promise<SonamuDBConfig> {
+    const dbConfigPath: string = path.join(
+      Sonamu.apiRootPath,
+      "/dist/configs/db"
+    );
     try {
-      const knexfileModule = await import(configPath);
-      this.knexfile = knexfileModule.default as SonamuDBConfig;
-      return this.knexfile;
+      const knexfileModule = await import(dbConfigPath);
+      return knexfileModule.default as SonamuDBConfig;
     } catch {}
 
     throw new ServiceUnavailableException(
-      `DB설정 파일을 찾을 수 없습니다. ${configPath}`
+      `DB설정 파일을 찾을 수 없습니다. ${dbConfigPath}`
     );
   }
 
-  getKnexfile(): SonamuDBConfig {
-    if (this.knexfile) {
-      return this.knexfile;
-    }
-
-    throw new ServiceUnavailableException("DB설정이 로드되지 않았습니다.");
-  }
-
   getDB(which: DBPreset): Knex {
-    const knexfile = this.getKnexfile();
+    const dbConfig = Sonamu.dbConfig;
 
     const instanceName = which === "w" ? "wdb" : "rdb";
 
@@ -57,17 +45,17 @@ class DBClass {
         case "staging":
           config =
             which === "w"
-              ? knexfile["development_master"]
-              : knexfile["development_slave"] ?? knexfile["development_master"];
+              ? dbConfig["development_master"]
+              : dbConfig["development_slave"] ?? dbConfig["development_master"];
           break;
         case "production":
           config =
             which === "w"
-              ? knexfile["production_master"]
-              : knexfile["production_slave"] ?? knexfile["production_master"];
+              ? dbConfig["production_master"]
+              : dbConfig["production_slave"] ?? dbConfig["production_master"];
           break;
         case "test":
-          config = knexfile["test"];
+          config = dbConfig["test"];
           break;
         default:
           throw new Error(

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from "./api/code-converters";
 export * from "./api/context";
 export * from "./api/decorators";
-export * from "./api/init";
+export * from "./api/sonamu";
 export * from "./database/base-model";
 export * from "./database/db";
 export * from "./database/upsert-builder";

package/src/smd/migrator.ts

@@ -49,17 +49,13 @@ import {
 import { propIf } from "../utils/lodash-able";
 import { SMDManager } from "./smd-manager";
 import { SMD } from "./smd";
-import { SonamuDBConfig } from "../database/db";
+import { Sonamu } from "../api";
 
 type MigratorMode = "dev" | "deploy";
 export type MigratorOptions = {
-  appRootPath: string;
-  knexfile: SonamuDBConfig;
   readonly mode: MigratorMode;
 };
 export class Migrator {
-  appRootPath: string;
-  knexfile: SonamuDBConfig;
   readonly mode: MigratorMode;
 
   targets: {
@@ -70,23 +66,21 @@ export class Migrator {
   };
 
   constructor(options: MigratorOptions) {
-    this.appRootPath = options.appRootPath;
-    this.knexfile = options.knexfile;
     this.mode = options.mode;
+    const { dbConfig } = Sonamu;
 
     if (this.mode === "dev") {
-      const devDB = knex(this.knexfile.development_master);
-      const testDB = knex(this.knexfile.test);
-      const fixtureLocalDB = knex(this.knexfile.fixture_local);
+      const devDB = knex(dbConfig.development_master);
+      const testDB = knex(dbConfig.test);
+      const fixtureLocalDB = knex(dbConfig.fixture_local);
 
       const applyDBs = [devDB, testDB, fixtureLocalDB];
       if (
-        (this.knexfile.fixture_local.connection as Knex.MySql2ConnectionConfig)
+        (dbConfig.fixture_local.connection as Knex.MySql2ConnectionConfig)
           .host !==
-        (this.knexfile.fixture_remote.connection as Knex.MySql2ConnectionConfig)
-          .host
+        (dbConfig.fixture_remote.connection as Knex.MySql2ConnectionConfig).host
       ) {
-        const fixtureRemoteDB = knex(this.knexfile.fixture_remote);
+        const fixtureRemoteDB = knex(dbConfig.fixture_remote);
         applyDBs.push(fixtureRemoteDB);
       }
 
@@ -97,8 +91,8 @@ export class Migrator {
         apply: applyDBs,
       };
     } else if (this.mode === "deploy") {
-      const productionDB = knex(this.knexfile.production_master);
-      const testDB = knex(this.knexfile.test);
+      const productionDB = knex(Sonamu.dbConfig.production_master);
+      const testDB = knex(Sonamu.dbConfig.test);
 
       this.targets = {
         pending: productionDB,
@@ -118,7 +112,7 @@ export class Migrator {
         directory: string;
       }[]
     ];
-    const migrationsDir = `${this.appRootPath}/api/src/migrations`;
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     const delList = pendingList.map((df) => {
       return path.join(migrationsDir, df.file).replace(".js", ".ts");
     });
@@ -197,7 +191,7 @@ export class Migrator {
     }
 
     // 실제 코드 생성
-    const migrationsDir = `${this.appRootPath}/api/src/migrations`;
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     codes
       .filter((code) => code.formatted)
       .map((code, index) => {
@@ -226,8 +220,7 @@ export class Migrator {
     const files = (["src", "dist"] as const).reduce(
       (r, which) => {
         const migrationPath = path.join(
-          this.appRootPath,
-          "api",
+          Sonamu.apiRootPath,
           which,
           "migrations"
         );
@@ -281,13 +274,7 @@ export class Migrator {
       }
 
       const filesToRm = diffOnDist.map((filename) => {
-        return path.join(
-          this.appRootPath,
-          "api",
-          "dist",
-          "migrations",
-          filename
-        );
+        return path.join(Sonamu.apiRootPath, "dist", "migrations", filename);
       });
       filesToRm.map((filePath) => {
         unlinkSync(filePath);
@@ -298,8 +285,8 @@ export class Migrator {
 
   async runShadowTest(): Promise<boolean> {
     // ShadowDB 생성 후 테스트 진행
-    const tdb = knex(this.knexfile.test);
-    const tdbConn = this.knexfile.test.connection as Knex.ConnectionConfig;
+    const tdb = knex(Sonamu.dbConfig.test);
+    const tdbConn = Sonamu.dbConfig.test.connection as Knex.ConnectionConfig;
     const shadowDatabase = tdbConn.database + "__migration_shadow";
     const tmpSqlPath = `/tmp/${shadowDatabase}.sql`;
 
@@ -330,7 +317,7 @@ export class Migrator {
 
     // shadow db 테스트 진행
     const sdb = knex({
-      ...this.knexfile.test,
+      ...Sonamu.dbConfig.test,
       connection: {
         ...tdbConn,
         database: shadowDatabase,
@@ -378,7 +365,7 @@ export class Migrator {
     console.log({ rollbackAllResult });
     console.timeEnd(chalk.red("rollback-all:"));
 
-    const migrationsDir = `${this.appRootPath}/api/src/migrations`;
+    const migrationsDir = `${Sonamu.apiRootPath}/src/migrations`;
     console.time(chalk.red("delete migration files"));
     execSync(`rm -f ${migrationsDir}/*`);
     execSync(`rm -f ${migrationsDir.replace("/src/", "/dist/")}/*`);

package/src/smd/smd-manager.ts

@@ -5,7 +5,7 @@ import _ from "lodash";
 import path from "path";
 import { SMD } from "./smd";
 import { SMDInput } from "../types/types";
-import { Syncer } from "../syncer/syncer";
+import { Sonamu } from "../api/sonamu";
 
 export type SMDNamesRecord = Record<
   | "fs"
@@ -34,8 +34,8 @@ class SMDManagerClass {
       return;
     }
     const pathPattern = path.join(
-      Syncer.getInstance().config.appRootPath,
-      "/api/dist/application/**/*.smd.js"
+      Sonamu.apiRootPath,
+      "/dist/application/**/*.smd.js"
     );
     !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
 

package/src/smd/smd.ts

@@ -21,7 +21,7 @@ import path from "path";
 import { existsSync } from "fs";
 import { z } from "zod";
 import { EnumsLabelKo } from "../types/types";
-import { Syncer } from "../syncer";
+import { Sonamu } from "../api/sonamu";
 
 export class SMD {
   id: string;
@@ -214,7 +214,9 @@ export class SMD {
                 to = `${joinAs}.id`;
               } else {
                 from = `${fromTable}.id`;
-                to = `${joinAs}.${relation.name}_id`;
+                to = `${joinAs}.${underscore(
+                  this.names.fs.replace(/\-/g, "_")
+                )}_id`;
               }
             } else {
               from = `${fromTable}.${relation.name}_id`;
@@ -435,7 +437,6 @@ export class SMD {
 
   registerModulePaths() {
     const basePath = `${this.names.fs}`;
-    const appRootPath = Syncer.getInstance().config.appRootPath;
 
     // base-scheme
     SMDManager.setModulePath(
@@ -463,9 +464,9 @@ export class SMD {
 
     // types
     const typesModulePath = `${basePath}/${this.names.fs}.types`;
-    const typesFileDistPath = path.resolve(
-      appRootPath,
-      `api/dist/application/${typesModulePath}.js`
+    const typesFileDistPath = path.join(
+      Sonamu.apiRootPath,
+      `dist/application/${typesModulePath}.js`
     );
 
     if (existsSync(typesFileDistPath)) {
@@ -483,9 +484,9 @@ export class SMD {
 
     // enums
     const enumsModulePath = `${basePath}/${this.names.fs}.enums`;
-    const enumsFileDistPath = path.resolve(
-      appRootPath,
-      `api/dist/application/${enumsModulePath}.js`
+    const enumsFileDistPath = path.join(
+      Sonamu.apiRootPath,
+      `/dist/application/${enumsModulePath}.js`
     );
     if (existsSync(enumsFileDistPath)) {
       const importPath = path.relative(__dirname, enumsFileDistPath);