sonamu 0.4.14 → 0.5.1

package/src/bin/build-config.ts

@@ -0,0 +1,10 @@
+/**
+ * SWC 빌드 명령어
+ */
+export const SWC_BUILD_COMMAND =
+  "swc src -d dist --strip-leading-paths --source-maps -C module.type=commonjs -C jsc.parser.syntax=typescript -C jsc.parser.decorators=true -C jsc.target=es5";
+
+/**
+ * TSC 타입 체크 명령어
+ */
+export const TSC_TYPE_CHECK_COMMAND = "tsc --noEmit";

package/src/bin/cli-wrapper.ts

@@ -1,41 +1,44 @@
 #!/usr/bin/env ts-node
 
-import { spawnSync } from "child_process";
-import { extname, resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-
-const cjsPath = resolve(__dirname, "bin/cli.js");
-const esmPath = resolve(__dirname, "bin/cli.mjs");
-
-const isESM = () => {
-  const packageJsonPath = resolve(process.cwd(), "package.json");
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-
-  // package.json에 "type": "module" 설정 확인
-  if (packageJson.type === "module") {
-    return true;
-  }
-
-  // 환경 변수에서 ESM 여부 확인
-  if (process.env.USE_ESM === "true") {
-    return true;
+import { spawnSync, execSync } from "child_process";
+import { resolve } from "path";
+import { existsSync } from "fs";
+import chalk from "chalk";
+import { SWC_BUILD_COMMAND, TSC_TYPE_CHECK_COMMAND } from "./build-config";
+
+const scriptPath = resolve(__dirname, "cli.js");
+const args = process.argv.slice(2);
+
+// build 명령어는 dist 없이도 실행 가능하도록 cli.ts 외부에서 처리(Sonamu.init에서 dist 필요)
+function build(checkTypes: boolean = false) {
+  try {
+    execSync(SWC_BUILD_COMMAND, { cwd: process.cwd(), stdio: "inherit" });
+  } catch (error) {
+    console.error(chalk.red("Build failed."), error);
+    process.exit(1);
   }
 
-  // package.json에 "type": "module" 설정
-  if (existsSync(packageJsonPath)) {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    return packageJson.type === "module";
-  }
-
-  // main 필드가 .mjs로 끝나는지 확인
-  if (packageJson.main && extname(packageJson.main) === ".mjs") {
-    return true;
+  if (checkTypes) {
+    try {
+      console.log(chalk.blue("Checking types with tsc..."));
+      execSync(TSC_TYPE_CHECK_COMMAND, { cwd: process.cwd(), stdio: "inherit" });
+    } catch (error) {
+      console.error(chalk.red("Type check failed."), error);
+      process.exit(1);
+    }
   }
+}
 
-  return false;
-};
+if (args[0] === "build") {
+  console.log(chalk.blue("Building the project..."));
+  build(true);
+  console.log(chalk.green("Build completed successfully."));
+  process.exit(0);
+}
 
-const scriptPath = isESM() ? esmPath : cjsPath;
+if (args[0] === "dev:serve") {
+  build();
+}
 
 if (!existsSync(scriptPath)) {
   console.error(`Error: Script not found at ${scriptPath}`);
@@ -44,7 +47,7 @@ if (!existsSync(scriptPath)) {
 
 const result = spawnSync(
   process.execPath,
-  [scriptPath, ...process.argv.slice(2)],
+  ["--no-warnings", scriptPath, ...args],
   {
     stdio: "inherit",
   }

package/src/bin/cli.ts

@@ -1,37 +1,29 @@
-/* Global Begin */
 import chalk from "chalk";
-console.log(chalk.bgBlue(`BEGIN ${new Date()}`));
-
 import dotenv from "dotenv";
 dotenv.config();
 
 import path from "path";
 import { tsicli } from "tsicli";
 import { execSync } from "child_process";
-import fs from "fs-extra";
-import inflection from "inflection";
-import prettier from "prettier";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { exists } from "../utils/fs-utils";
 import process from "process";
-import _ from "lodash";
 import { Sonamu } from "../api";
+import knex, { Knex } from "knex";
+import { findApiRootPath } from "../utils/utils";
 import { EntityManager } from "../entity/entity-manager";
-import { Migrator } from "../entity/migrator";
+import { Migrator } from "../migration/migrator";
 import { FixtureManager } from "../testing/fixture-manager";
-import { SMDManager } from "../smd/smd-manager";
-import { DB } from "../database/db";
-import {
-  KnexConfig,
-  KyselyConfig,
-  SonamuKnexDBConfig,
-  SonamuKyselyDBConfig,
-} from "../database/types";
-import { KnexClient } from "../database/drivers/knex/client";
-import { KyselyClient } from "../database/drivers/kysely/client";
+// import { SWC_BUILD_COMMAND } from "./build-config";
+import { NodemonSettings } from "nodemon";
 
 let migrator: Migrator;
 
 async function bootstrap() {
-  await Sonamu.init(false, false);
+  // dev:serve 명령어가 아닌 경우에만 Sonamu 초기화
+  if (process.argv[2] !== "dev:serve") {
+    await Sonamu.init(false, false);
+  }
 
   await tsicli(process.argv, {
     types: {
@@ -64,7 +56,8 @@ async function bootstrap() {
       ["scaffold", "view_list", "#entityId"],
       ["scaffold", "view_form", "#entityId"],
       ["ui"],
-      ["smd_migration"],
+      ["dev:serve"],
+      ["serve"],
     ],
     runners: {
       migrate_run,
@@ -83,7 +76,8 @@ async function bootstrap() {
       ui,
       // scaffold_view_list,
       // scaffold_view_form,
-      smd_migration,
+      "dev:serve": dev_serve,
+      serve,
     },
   });
 }
@@ -91,12 +85,69 @@ bootstrap().finally(async () => {
   if (migrator) {
     await migrator.destroy();
   }
-  await FixtureManager.destory();
-
-  /* Global End */
-  console.log(chalk.bgBlue(`END ${new Date()}\n`));
+  await FixtureManager.destroy();
 });
 
+async function dev_serve() {
+  const nodemon = await import("nodemon");
+
+  const nodemonConfig = await (async () => {
+    const projectNodemonPath = path.join(findApiRootPath(), "nodemon.json");
+    const hasProjectNodemon = await exists(projectNodemonPath);
+
+    if (hasProjectNodemon) {
+      return JSON.parse(await readFile(projectNodemonPath, "utf8"));
+    }
+
+    return {
+      watch: ["src/index.ts"],
+      ignore: ["dist/**", "**/*.js", "**/*.d.ts"],
+      exec: [
+        // SWC_BUILD_COMMAND,
+        "node --no-warnings -r source-map-support/register -r dotenv/config dist/index.js",
+      ].join(" && "),
+    } as NodemonSettings;
+  })();
+  nodemon.default(nodemonConfig);
+
+  // 프로세스 종료 처리
+  const cleanup = async () => {
+    await Sonamu.server?.close();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.on("SIGUSR2", cleanup);
+}
+
+async function serve() {
+  const distIndexPath = path.join(Sonamu.apiRootPath, "dist", "index.js");
+
+  if (!(await exists(distIndexPath))) {
+    console.log(
+      chalk.red("dist/index.js not found. Please build your project first.")
+    );
+    console.log(chalk.blue("Run: yarn sonamu build"));
+    return;
+  }
+
+  const { spawn } = await import("child_process");
+  const serverProcess = spawn(
+    "node",
+    ["-r", "source-map-support/register", "-r", "dotenv/config", distIndexPath],
+    {
+      cwd: Sonamu.apiRootPath,
+      stdio: "inherit",
+    }
+  );
+
+  process.on("SIGINT", () => {
+    serverProcess.kill("SIGTERM");
+    process.exit(0);
+  });
+}
+
 async function setupMigrator() {
   // migrator
   migrator = new Migrator({
@@ -149,97 +200,93 @@ async function migrate_reset() {
 }
 
 async function fixture_init() {
-  const _db = DB.getClient("development_master");
-  const srcConn = _db.connectionInfo;
-
+  const srcConfig = Sonamu.dbConfig.development_master;
   const targets = [
     {
       label: "(REMOTE) Fixture DB",
-      connKey: "fixture_remote",
+      config: Sonamu.dbConfig.fixture_remote,
     },
     {
       label: "(LOCAL) Fixture DB",
-      connKey: "fixture_local",
+      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",
-      connKey: "test",
+      config: Sonamu.dbConfig.test,
     },
   ] as {
     label: string;
-    connKey: keyof SonamuKnexDBConfig | keyof SonamuKyselyDBConfig;
+    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;
   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}`
+    `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction -d --no-create-db --triggers ${srcConn.database} > ${dumpFilename}`
   );
-
-  // 2. 마이그레이션 테이블이 존재하면 덤프
-  const dbClient = DB.baseConfig!.client;
-  const migrationTable = DB.migrationTable;
-  const [migrations] = await _db.raw<{ count: number }>(
-    "SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = ?",
-    [srcConn.database, migrationTable]
+  const _db = knex(srcConfig);
+  const [[migrations]] = await _db.raw(
+    "SELECT COUNT(*) as count FROM information_schema.tables WHERE table_schema = ? AND table_name = 'knex_migrations'",
+    [srcConn.database]
   );
   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}`
+      `mysqldump -h${srcConn.host} -u${srcConn.user} -p${srcConn.password} --single-transaction --no-create-db --triggers ${srcConn.database} knex_migrations knex_migrations_lock > ${migrationsDump}`
     );
   }
 
   // 2. 대상DB 각각에 대하여 존재여부 확인 후 붓기
-  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
-      )
-    ) {
+  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 = (() => {
-      if (dbClient === "knex") {
-        const config = _.cloneDeep(DB.fullConfig[connKey]) as KnexConfig;
-        config.connection.database = undefined;
-        return new KnexClient(config);
-      } else {
-        const config = _.cloneDeep(DB.fullConfig[connKey]) as KyselyConfig;
-        config.database = undefined;
-        return new KyselyClient(config);
-      }
-    })();
-
-    const [row] = await db.raw(`SHOW DATABASES LIKE "${config.database}"`);
+    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 "${config.database}" Already exists`)
+        chalk.yellow(`${label}: Database "${conn.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 (fs.existsSync(migrationsDump)) {
-      execSync(`${mysqlCmd} ${config.database} < ${migrationsDump}`);
+    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}`);
+    if (await exists(migrationsDump)) {
+      execSync(`${mysqlCmd} ${conn.database} < ${migrationsDump}`);
     }
 
     await db.destroy();
   }
+
+  await _db.destroy();
 }
 
 async function fixture_import(entityId: string, recordIds: number[]) {
@@ -257,11 +304,11 @@ async function fixture_sync() {
 
 async function stub_practice(name: string) {
   const practiceDir = path.join(Sonamu.apiRootPath, "src", "practices");
-  const fileNames = fs.readdirSync(practiceDir);
+  const fileNames = await readdir(practiceDir);
 
-  const maxSeqNo = (() => {
-    if (fs.existsSync(practiceDir) === false) {
-      fs.mkdirSync(practiceDir, { recursive: true });
+  const maxSeqNo = await (async () => {
+    if (!(await exists(practiceDir))) {
+      await mkdir(practiceDir, { recursive: true });
     }
 
     const filteredSeqs = fileNames
@@ -285,25 +332,22 @@ async function stub_practice(name: string) {
   const fileName = `p${currentSeqNo}-${name}.ts`;
   const dstPath = path.join(practiceDir, fileName);
 
-  // FIXME
   const code = [
-    `import { BaseModel } from "sonamu";`,
+    `import { Sonamu } from "sonamu";`,
     "",
     `console.clear();`,
     `console.log("${fileName}");`,
     "",
-    `async function bootstrap() {`,
+    `Sonamu.runScript(async () => {`,
     ` // TODO`,
-    `}`,
-    `bootstrap().finally(async () => {`,
-    `await BaseModel.destroy();`,
     `});`,
+    "",
   ].join("\n");
-  fs.writeFileSync(dstPath, code);
+  await writeFile(dstPath, code);
 
   execSync(`code ${dstPath}`);
 
-  const runCode = `yarn node -r source-map-support/register dist/practices/${fileName.replace(
+  const runCode = `yarn node -r dotenv/config -r source-map-support/register dist/practices/${fileName.replace(
     ".ts",
     ".js"
   )}`;
@@ -329,10 +373,20 @@ async function scaffold_model_test(entityId: string) {
 
 async function ui() {
   try {
+    type StartServersOptions = {
+      projectName: string;
+      apiRootPath: string;
+      port: number;
+    };
     const sonamuUI: {
-      startServers: (appRootPath: string) => void;
+      startServers: (options: StartServersOptions) => void;
     } = await import("@sonamu-kit/ui" as string);
-    sonamuUI.startServers(Sonamu.apiRootPath);
+    sonamuUI.startServers({
+      projectName:
+        Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),
+      apiRootPath: Sonamu.apiRootPath,
+      port: Sonamu.config.ui?.port ?? 57000,
+    });
   } 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.`);
@@ -341,120 +395,3 @@ async function ui() {
     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 + inflection.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 = await prettier.format(JSON.stringify(entityJson), {
-      parser: "json",
-    });
-    fs.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 (fs.existsSync(p) === false) {
-        console.log(chalk.yellow(`NOT FOUND: ${p}`));
-        return;
-      }
-      fs.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/_batch_update.ts

@@ -4,11 +4,6 @@
 */
 
 import { Knex } from "knex";
-import { DB } from "./db";
-import { KnexClient } from "./drivers/knex/client";
-import { KyselyClient } from "./drivers/kysely/client";
-import { Transaction } from "kysely";
-import { Database } from "./types";
 
 export type RowWithId<Id extends string> = {
   [key in Id]: any;
@@ -24,12 +19,12 @@ export type RowWithId<Id extends string> = {
  * @param trx
  */
 export async function batchUpdate<Id extends string>(
-  db: KnexClient | KyselyClient,
+  knex: Knex,
   tableName: string,
   ids: Id[],
   rows: RowWithId<Id>[],
   chunkSize = 50,
-  trx: Knex.Transaction | Transaction<Database> | null = null
+  trx: Knex.Transaction | null = null
 ) {
   const chunks: RowWithId<Id>[][] = [];
   for (let i = 0; i < rows.length; i += chunkSize) {
@@ -38,18 +33,18 @@ export async function batchUpdate<Id extends string>(
 
   const executeUpdate = async (
     chunk: RowWithId<Id>[],
-    transaction: KyselyClient | KnexClient
+    transaction: Knex.Transaction
   ) => {
-    const sql = generateBatchUpdateSQL(db, tableName, chunk, ids);
-    return transaction.raw(sql);
+    const sql = generateBatchUpdateSQL(knex, tableName, chunk, ids);
+    return knex.raw(sql).transacting(transaction);
   };
 
   if (trx) {
     for (const chunk of chunks) {
-      await executeUpdate(chunk, DB.toClient(trx));
+      await executeUpdate(chunk, trx);
     }
   } else {
-    await db.trx(async (newTrx) => {
+    await knex.transaction(async (newTrx) => {
       for (const chunk of chunks) {
         await executeUpdate(chunk, newTrx);
       }
@@ -75,7 +70,7 @@ function generateKeySetFromData(data: Record<string, any>[]) {
 }
 
 function generateBatchUpdateSQL<Id extends string>(
-  db: KnexClient | KyselyClient,
+  db: Knex,
   tableName: string,
   data: Record<string, any>[],
   identifiers: Id[]
@@ -117,10 +112,10 @@ function generateBatchUpdateSQL<Id extends string>(
     data.map((row) => row[col])
   );
 
-  const sql = db.createRawQuery(
+  const sql = db.raw(
     `UPDATE \`${tableName}\` SET ${cases.join(", ")} WHERE ${whereInClauses}`,
     [...bindings, ...whereInBindings]
   );
 
-  return sql;
+  return sql.toQuery();
 }