sonamu 0.0.41 → 0.1.0

package/src/bin/cli.ts

@@ -7,13 +7,24 @@ dotenv.config();
 
 import path from "path";
 import { BaseModel } from "../database/base-model";
-import { SMDManager } from "../smd/smd-manager";
-import { Migrator } from "../smd/migrator";
+import { EntityManager } from "../entity/entity-manager";
+import { Migrator } from "../entity/migrator";
 import { FixtureManager } from "../testing/fixture-manager";
 import { tsicli } from "tsicli";
 import { execSync } from "child_process";
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync,
+} from "fs";
 import { Sonamu } from "../api";
+import knex, { Knex } from "knex";
+import { camelize } from "inflection";
+import prettier from "prettier";
+import { SMDManager } from "../smd/smd-manager";
+import process from "process";
 
 let migrator: Migrator;
 
@@ -22,20 +33,21 @@ async function bootstrap() {
 
   await tsicli(process.argv, {
     types: {
-      "#smdId": {
+      "#entityId": {
         type: "autocomplete",
-        name: "#smdId",
-        message: "Please input #smdId",
-        choices: SMDManager.getAllParentIds().map((smdId) => ({
-          title: smdId,
-          value: smdId,
+        name: "#entityId",
+        message: "Please input #entityId",
+        choices: EntityManager.getAllParentIds().map((entityId) => ({
+          title: entityId,
+          value: entityId,
         })),
       },
       "#recordIds": "number[]",
       "#name": "string",
     },
     args: [
-      ["fixture", "import", "#smdId", "#recordIds"],
+      ["fixture", "init"],
+      ["fixture", "import", "#entityId", "#recordIds"],
       ["fixture", "sync"],
       ["migrate", "run"],
       ["migrate", "check"],
@@ -43,11 +55,13 @@ async function bootstrap() {
       ["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"],
+      ["stub", "entity", "#name"],
+      ["scaffold", "model", "#entityId"],
+      ["scaffold", "model_test", "#entityId"],
+      ["scaffold", "view_list", "#entityId"],
+      ["scaffold", "view_form", "#entityId"],
+      ["ui"],
+      ["smd_migration"],
     ],
     runners: {
       migrate_run,
@@ -55,14 +69,17 @@ async function bootstrap() {
       migrate_rollback,
       migrate_clear,
       migrate_reset,
+      fixture_init,
       fixture_import,
       fixture_sync,
       stub_practice,
-      stub_smd,
+      stub_entity,
       scaffold_model,
       scaffold_model_test,
+      ui,
       // scaffold_view_list,
       // scaffold_view_form,
+      smd_migration,
     },
   });
 }
@@ -120,10 +137,84 @@ async function migrate_reset() {
   await migrator.resetAll();
 }
 
-async function fixture_import(smdId: string, recordIds: number[]) {
+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 as Knex.ConnectionConfig;
+        const localConn = Sonamu.dbConfig.fixture_local
+          .connection as Knex.ConnectionConfig;
+        return (
+          remoteConn.host === localConn.host &&
+          remoteConn.database === localConn.database
+        );
+      })(),
+    },
+    {
+      label: "(LOCAL) Testing DB",
+      config: Sonamu.dbConfig.test,
+    },
+  ] as {
+    label: string;
+    config: Knex.Config;
+    toSkip?: boolean;
+  }[];
+
+  // 1. 기준DB 스키마를 덤프
+  console.log("DUMP...");
+  const dumpFilename = `/tmp/sonamu-fixture-init-${Date.now()}.sql`;
+  const srcConn = srcConfig.connection as Knex.ConnectionConfig;
+  execSync(
+    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
+  );
+
+  // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기
+  for await (const { label, config, toSkip } of targets) {
+    const conn = config.connection as Knex.ConnectionConfig;
+
+    if (toSkip === true) {
+      console.log(chalk.red(`${label}: Skipped!`));
+      continue;
+    }
+
+    const db = knex({
+      ...config,
+      connection: {
+        ...((config.connection ?? {}) as Knex.ConnectionConfig),
+        database: undefined,
+      },
+    });
+    const [[row]] = await db.raw(`SHOW DATABASES LIKE "${conn.database}"`);
+    if (row) {
+      console.log(
+        chalk.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 db.destroy();
+  }
+}
+
+async function fixture_import(entityId: string, recordIds: number[]) {
   await setupFixtureManager();
 
-  await FixtureManager.importFixture(smdId, recordIds);
+  await FixtureManager.importFixture(entityId, recordIds);
   await FixtureManager.sync();
 }
 
@@ -188,20 +279,150 @@ async function stub_practice(name: string) {
   execSync(`echo "${runCode}" | pbcopy`);
 }
 
-async function stub_smd(name: string) {
-  await Sonamu.syncer.generateTemplate("smd", {
-    smdId: name,
-  });
+async function stub_entity(entityId: string) {
+  await Sonamu.syncer.createEntity(entityId);
 }
 
-async function scaffold_model(smdId: string) {
+async function scaffold_model(entityId: string) {
   await Sonamu.syncer.generateTemplate("model", {
-    smdId,
+    entityId,
   });
 }
 
-async function scaffold_model_test(smdId: string) {
+async function scaffold_model_test(entityId: string) {
   await Sonamu.syncer.generateTemplate("model_test", {
-    smdId,
+    entityId,
   });
 }
+
+async function ui() {
+  try {
+    const sonamuUI: {
+      startServers: (appRootPath: string) => void;
+    } = await import("@sonamu-kit/ui" as string);
+    sonamuUI.startServers(Sonamu.appRootPath);
+  } catch (e: unknown) {
+    if (e instanceof Error && e.message.includes("isn't declared")) {
+      console.log(`You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`);
+      return;
+    }
+    throw e;
+  }
+}
+
+async function smd_migration() {
+  await SMDManager.autoload();
+  const smdIds = SMDManager.getAllIds();
+
+  function enumLabelsToEntityEnums(
+    entityId: string,
+    enumLabels: {
+      [enumName: string]: { [name: string]: { ko: string } };
+    }
+  ): { [enumName: string]: { [name: string]: string } } {
+    return Object.fromEntries(
+      Object.entries(enumLabels).map(([enumLabelName, enumLabel]) => {
+        const enumName =
+          entityId + 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 = path.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.entity.json`
+    );
+
+    const formatted = prettier.format(JSON.stringify(entityJson), {
+      parser: "json",
+    });
+    writeFileSync(dstPath, formatted);
+    console.log(chalk.blue(`CREATED: ${dstPath}`));
+
+    // smd.ts, enums.ts, genereated.ts 삭제 (트랜스파일 된 js파일도 삭제)
+    const srcSmdPath = path.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.smd.ts`
+    );
+    const dstSmdPath = srcSmdPath
+      .replace("/src/", "/dist/")
+      .replace(/\.ts$/, ".js");
+    const srcEnumsPath = path.join(
+      Sonamu.apiRootPath,
+      "src",
+      "application",
+      parentNames.fs,
+      `${names.fs}.enums.ts`
+    );
+    const dstEnumsPath = srcEnumsPath
+      .replace("/src/", "/dist/")
+      .replace(/\.ts$/, ".js");
+    const srcGeneratedPath = path.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, path.join(Sonamu.appRootPath, target))
+          .replace("/src/application/", "/src/services/")
+      ),
+      srcGeneratedPath,
+      dstGeneratedPath,
+    ].map((p) => {
+      if (existsSync(p) === false) {
+        console.log(chalk.yellow(`NOT FOUND: ${p}`));
+        return;
+      }
+      unlinkSync(p);
+      console.log(chalk.red(`DELETED: ${p}`));
+    });
+  }
+
+  // Entity로 reload
+  console.log("Entity로 다시 로드합니다.");
+  EntityManager.isAutoloaded = false;
+  await EntityManager.autoload();
+
+  // Entity를 통해 generated.ts 재생성
+  const entityIds = EntityManager.getAllParentIds();
+  for await (const entityId of entityIds) {
+    await Sonamu.syncer.generateTemplate("generated", { entityId });
+  }
+}

package/src/database/upsert-builder.ts

@@ -1,7 +1,7 @@
 import { v4 as uuidv4 } from "uuid";
 import _, { chunk, defaults, groupBy } from "lodash";
 import { Knex } from "knex";
-import { SMDManager } from "../smd/smd-manager";
+import { EntityManager } from "../entity/entity-manager";
 
 type TableData = {
   references: Set<string>;
@@ -34,7 +34,7 @@ export class UpsertBuilder {
     if (table === undefined) {
       const tableSpec = (() => {
         try {
-          return SMDManager.getTableSpec(tableName);
+          return EntityManager.getTableSpec(tableName);
         } catch {
           return null;
         }

package/src/entity/entity-manager.ts

@@ -0,0 +1,150 @@
+import chalk from "chalk";
+import { glob } from "glob";
+import { dasherize, underscore, pluralize, camelize } from "inflection";
+import _ from "lodash";
+import path from "path";
+import { Entity } from "./entity";
+import { EntityJson } from "../types/types";
+import { Sonamu } from "../api/sonamu";
+import { readFileSync } from "fs";
+
+export type EntityNamesRecord = Record<
+  | "fs"
+  | "fsPlural"
+  | "camel"
+  | "camelPlural"
+  | "capital"
+  | "capitalPlural"
+  | "upper"
+  | "constant",
+  string
+>;
+type TableSpec = {
+  name: string;
+  uniqueColumns: string[];
+};
+class EntityManagerClass {
+  private entities: Map<string, Entity> = new Map();
+  public modulePaths: Map<string, string> = new Map();
+  private tableSpecs: Map<string, TableSpec> = new Map();
+  public isAutoloaded: boolean = false;
+
+  // 경로 전달받아 모든 entity.json 파일 로드
+  async autoload(doSilent: boolean = false) {
+    if (this.isAutoloaded) {
+      return;
+    }
+    const pathPattern = path.join(
+      Sonamu.apiRootPath,
+      "/src/application/**/*.entity.json"
+    );
+    !doSilent && console.log(chalk.yellow(`autoload ${pathPattern}`));
+
+    return new Promise((resolve) => {
+      glob(path.resolve(pathPattern!), (_err, files) => {
+        Promise.all(
+          files.map(async (file) => {
+            this.register(JSON.parse(readFileSync(file).toString()));
+          })
+        ).then(() => {
+          resolve("ok");
+          this.isAutoloaded = true;
+        });
+      });
+    });
+  }
+
+  async reload(doSilent: boolean = false) {
+    this.entities.clear();
+    this.modulePaths.clear();
+    this.tableSpecs.clear();
+    this.isAutoloaded = false;
+
+    return this.autoload(doSilent);
+  }
+
+  register(json: EntityJson): void {
+    const entity = new Entity(json);
+    this.entities.set(json.id, entity);
+  }
+
+  get(entityId: string): Entity {
+    const entity = this.entities.get(entityId);
+    if (entity === undefined) {
+      throw new Error(`존재하지 않는 Entity 요청 ${entityId}`);
+    }
+
+    return entity;
+  }
+
+  exists(entityId: string): boolean {
+    const entity = this.entities.get(entityId);
+    return entity !== undefined;
+  }
+
+  getAllIds(): string[] {
+    return Array.from(EntityManager.entities.keys());
+  }
+
+  getAllParentIds(): string[] {
+    return this.getAllIds().filter((entityId) => {
+      const entity = this.get(entityId);
+      return entity.parentId === undefined;
+    });
+  }
+
+  getChildrenIds(parentId: string): string[] {
+    return this.getAllIds().filter((entityId) => {
+      const entity = this.get(entityId);
+      return entity.parentId === parentId;
+    });
+  }
+
+  setModulePath(key: string, modulePath: string): void {
+    // console.debug(chalk.cyan(`setModulePath :: ${key} :: ${modulePath}`));
+    this.modulePaths.set(key, modulePath);
+  }
+
+  getModulePath(key: string): string {
+    const modulePath = this.modulePaths.get(key);
+    if (modulePath === undefined) {
+      throw new Error(`존재하지 않는 모듈 패스 요청 ${key}`);
+    }
+
+    return modulePath;
+  }
+
+  setTableSpec(tableSpec: TableSpec) {
+    this.tableSpecs.set(tableSpec.name, tableSpec);
+  }
+
+  getTableSpec(key: string): TableSpec {
+    const tableSpec = this.tableSpecs.get(key);
+    if (tableSpec === undefined) {
+      throw new Error(`존재하지 않는 테이블 스펙 요청 ${key}`);
+    }
+
+    return tableSpec;
+  }
+
+  getNamesFromId(entityId: string): EntityNamesRecord {
+    // entityId가 단복수 동형 단어인 경우 List 붙여서 생성
+    const pluralized =
+      pluralize(entityId) === entityId
+        ? `${entityId}List`
+        : pluralize(entityId);
+
+    return {
+      fs: dasherize(underscore(entityId)).toLowerCase(),
+      fsPlural: dasherize(underscore(pluralized)).toLowerCase(),
+      camel: camelize(entityId, true),
+      camelPlural: camelize(pluralized, true),
+      capital: entityId,
+      capitalPlural: pluralized,
+      upper: entityId.toUpperCase(),
+      constant: underscore(entityId).toUpperCase(),
+    };
+  }
+}
+
+export const EntityManager = new EntityManagerClass();

package/src/{smd/smd-utils.ts → entity/entity-utils.ts}

@@ -15,7 +15,7 @@ import {
   JsonProp,
   ManyToManyRelationProp,
   OneToOneRelationProp,
-  SMDIndex,
+  EntityIndex,
   StringProp,
   TextProp,
   TimeProp,
@@ -212,10 +212,7 @@ function enums(
 }
 function virtual(
   name: string,
-  option: Omit<
-    VirtualProp,
-    "name" | "type" | "index" | "unique" | "dbDefault" | "toFilter"
-  >
+  option: Omit<VirtualProp, "name" | "type" | "dbDefault" | "toFilter">
 ): VirtualProp {
   return {
     name,
@@ -276,14 +273,14 @@ export const i = {
   unique,
 };
 
-function index(columns: string | string[]): SMDIndex {
+function index(columns: string | string[]): EntityIndex {
   return {
     type: "index",
     columns: asArray(columns),
   };
 }
 
-function unique(columns: string | string[]): SMDIndex {
+function unique(columns: string | string[]): EntityIndex {
   return {
     type: "unique",
     columns: asArray(columns),