sonamu 0.5.7 → 0.6.0

package/src/bin/cli-wrapper.ts

@@ -10,7 +10,7 @@ import {
   TSC_TYPE_CHECK_COMMAND,
 } from "./build-config";
 
-const scriptPath = resolve(__dirname, "cli.js");
+const scriptPath = resolve(import.meta.dirname, "cli.js");
 const args = process.argv.slice(2);
 
 // build 명령어는 dist 없이도 실행 가능하도록 cli.ts 외부에서 처리(Sonamu.init에서 dist 필요)
@@ -56,7 +56,7 @@ if (args[0] === "build") {
 }
 
 if (args[0] === "dev:serve") {
-  build();
+  // build();
 }
 
 if (!existsSync(scriptPath)) {
@@ -66,7 +66,14 @@ if (!existsSync(scriptPath)) {
 
 const result = spawnSync(
   process.execPath,
-  ["-r", "source-map-support/register", "--no-warnings", scriptPath, ...args],
+  [
+    "--import",
+    "@sonamu-kit/loader", // Sonamu UI도 syncer를 다루므로, ts 로드 능력이 필요합니다.
+    "--enable-source-maps",
+    "--no-warnings",
+    scriptPath,
+    ...args
+  ],
   {
     stdio: "inherit",
   }

package/src/bin/cli.ts

@@ -3,25 +3,24 @@ import dotenv from "dotenv";
 dotenv.config();
 
 import path from "path";
+import { fileURLToPath } from "url";
 import { tsicli } from "tsicli";
-import { execSync } from "child_process";
-import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { execSync, spawn } from "child_process";
+import { mkdir, readdir, writeFile } from "fs/promises";
 import { exists } from "../utils/fs-utils";
 import process from "process";
 import { Sonamu } from "../api";
 import knex, { Knex } from "knex";
-import { findApiRootPath } from "../utils/utils";
 import { EntityManager } from "../entity/entity-manager";
 import { Migrator } from "../migration/migrator";
 import { FixtureManager } from "../testing/fixture-manager";
-// import { SWC_BUILD_COMMAND } from "./build-config";
-import { NodemonSettings } from "nodemon";
+import { findApiRootPath } from "../utils/utils";
 
 let migrator: Migrator;
 
 async function bootstrap() {
-  // dev:serve 명령어가 아닌 경우에만 Sonamu 초기화
-  if (process.argv[2] !== "dev:serve") {
+  // dev 명령어가 아닌 경우에만 Sonamu 초기화
+  if (process.argv[2] !== "dev") {
     await Sonamu.init(false, false);
   }
 
@@ -56,8 +55,8 @@ async function bootstrap() {
       ["scaffold", "view_list", "#entityId"],
       ["scaffold", "view_form", "#entityId"],
       ["ui"],
-      ["dev:serve"],
-      ["serve"],
+      ["dev"],
+      ["start"],
     ],
     runners: {
       migrate_run,
@@ -76,8 +75,8 @@ async function bootstrap() {
       ui,
       // scaffold_view_list,
       // scaffold_view_form,
-      "dev:serve": dev_serve,
-      serve,
+      dev,
+      start,
     },
   });
 }
@@ -88,45 +87,57 @@ bootstrap().finally(async () => {
   await FixtureManager.destroy();
 });
 
-async function dev_serve() {
-  const nodemon = await import("nodemon");
+async function dev() {
+  const apiRoot = findApiRootPath();
+  const entryPoint = 'src/index.ts';   
 
-  const nodemonConfig = await (async () => {
-    const projectNodemonPath = path.join(findApiRootPath(), "nodemon.json");
-    const hasProjectNodemon = await exists(projectNodemonPath);
+  console.log(chalk.yellow.bold('🚀 Starting Sonamu dev server...\n'));
 
-    if (hasProjectNodemon) {
-      return JSON.parse(await readFile(projectNodemonPath, "utf8"));
+  const serverProcess = spawn(
+    "hot-runner",
+    [
+      "--clear-screen=false",
+      "--node-args=--import=@sonamu-kit/loader",
+      "--node-args=--import=sonamu/hot-hook-register",
+      "--node-args=--enable-source-maps",
+      entryPoint,
+    ],
+    {
+      cwd: apiRoot,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        NODE_ENV: "development",
+        HOT: "yes",
+        API_ROOT_PATH: apiRoot,
+      },
     }
+  );
 
-    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();
+  // 종료 처리
+  const cleanup = () => {
+    console.log(chalk.yellow('\n\n👋 Shutting down...'));
+    serverProcess.kill('SIGTERM');
     process.exit(0);
   };
 
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  process.on("SIGUSR2", cleanup);
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+
+  serverProcess.on('exit', (code) => {
+    if (code !== 0) {
+      console.error(chalk.red(`❌ Server exited with code ${code}`));
+      process.exit(code || 1);
+    }
+  });
 }
 
-async function serve() {
-  const distIndexPath = path.join(Sonamu.apiRootPath, "dist", "index.js");
+async function start() {
+  const entryPoint = 'dist/index.js';  
 
-  if (!(await exists(distIndexPath))) {
+  if (!(await exists(entryPoint))) {
     console.log(
-      chalk.red("dist/index.js not found. Please build your project first.")
+      chalk.red(`${entryPoint} not found. Please build your project first.`)
     );
     console.log(chalk.blue("Run: yarn sonamu build"));
     return;
@@ -135,7 +146,7 @@ async function serve() {
   const { spawn } = await import("child_process");
   const serverProcess = spawn(
     "node",
-    ["-r", "source-map-support/register", "-r", "dotenv/config", distIndexPath],
+    ["--enable-source-maps", "-r", "dotenv/config", entryPoint],
     {
       cwd: Sonamu.apiRootPath,
       stdio: "inherit",
@@ -162,14 +173,12 @@ async function setupFixtureManager() {
 async function migrate_run() {
   await setupMigrator();
 
-  await migrator.cleanUpDist();
   await migrator.run();
 }
 
 async function migrate_check() {
   await setupMigrator();
 
-  await migrator.cleanUpDist();
   await migrator.check();
 }
 
@@ -347,7 +356,7 @@ async function stub_practice(name: string) {
 
   execSync(`code ${dstPath}`);
 
-  const runCode = `yarn node -r dotenv/config -r source-map-support/register dist/practices/${fileName.replace(
+  const runCode = `yarn node -r dotenv/config --enable-source-maps dist/practices/${fileName.replace(
     ".ts",
     ".js"
   )}`;
@@ -373,23 +382,66 @@ async function scaffold_model_test(entityId: string) {
 
 async function ui() {
   try {
-    type StartServersOptions = {
-      projectName: string;
-      apiRootPath: string;
-      port: number;
+    // @sonamu-kit/ui의 run-ui.ts 스크립트 경로 찾기
+    const uiModulePath = await import.meta.resolve("@sonamu-kit/ui");
+    const uiNodePath = path.join(
+      path.dirname(fileURLToPath(uiModulePath)),
+      "run-ui.js"
+    );
+
+    if (!(await exists(uiNodePath))) {
+      console.log(
+        chalk.red(
+          `UI runner script not found at ${uiNodePath}. Please rebuild @sonamu-kit/ui.`
+        )
+      );
+      return;
+    }
+
+    // UI를 별도 프로세스로 실행 (hot-hook 활성화)
+    const uiProcess = spawn(
+      process.execPath,
+      [
+        "--import", "@sonamu-kit/loader",
+        "--import", "sonamu/hot-hook-register",
+        "--enable-source-maps",
+        "--no-warnings",
+        uiNodePath,
+      ],
+      {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          HOT: "yes",
+          PROJECT_NAME:
+            Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),
+          API_ROOT_PATH: Sonamu.apiRootPath,
+          UI_PORT: (Sonamu.config.ui?.port ?? 57000).toString(),
+        },
+      }
+    );
+
+    // 종료 처리
+    const cleanup = () => {
+      console.log(chalk.yellow("\n\n👋 Shutting down UI server..."));
+      uiProcess.kill("SIGTERM");
+      process.exit(0);
     };
-    const sonamuUI: {
-      startServers: (options: StartServersOptions) => void;
-    } = await import("@sonamu-kit/ui" as string);
-    sonamuUI.startServers({
-      projectName:
-        Sonamu.config.projectName ?? path.basename(Sonamu.apiRootPath),
-      apiRootPath: Sonamu.apiRootPath,
-      port: Sonamu.config.ui?.port ?? 57000,
+
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+
+    uiProcess.on("exit", (code) => {
+      if (code !== 0) {
+        console.error(chalk.red(`❌ UI server exited with code ${code}`));
+        process.exit(code || 1);
+      }
     });
   } 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.`);
+      console.log(
+        `You need to install ${chalk.blue(`@sonamu-kit/ui`)} first.`
+      );
       return;
     }
     throw e;

package/src/bin/hot-hook-register.ts

@@ -0,0 +1,22 @@
+/**
+ * hot-hook 초기화하는 모듈입니다.
+ *
+ * 이 파일은 --import 플래그로 프로세스 시작 시 로드되어야 합니다.
+ *
+ * 환경변수:
+ * - API_ROOT_PATH: 사용자 프로젝트의 API 루트 경로
+ * - HOT: 'yes'일 때만 hot-hook 활성화
+ */
+
+if (process.env.HOT === "yes" && process.env.API_ROOT_PATH) {
+  const { hot } = await import("@sonamu-kit/hot-hook");
+
+  await hot.init({
+    rootDirectory: process.env.API_ROOT_PATH, // 이 친구가 프로젝트 API 경로로 잘 설정되어야 아래 바운더리가 작동합니다.
+    boundaries: [`./src/**/*.ts`], // 프로젝트의 이 친구들이 바운더리가 됩니다.
+  });
+
+  console.log("🔥 Hot-hook initialized");
+}
+
+export {};

package/src/database/base-model.ts

@@ -1,6 +1,6 @@
 import { DateTime } from "luxon";
 import { Knex } from "knex";
-import { chunk, groupBy, isObject, omit, set, uniq } from "lodash";
+import { chunk, groupBy, isObject, omit, set, uniq } from "lodash-es";
 import { DBPreset, DB } from "./db";
 import { isCustomJoinClause, type SubsetQuery } from "../types/types";
 import type { BaseListParams } from "../utils/model";

package/src/database/code-generator.ts

@@ -1,4 +1,4 @@
-import _ from "lodash";
+import * as _ from "lodash-es";
 import equal from "fast-deep-equal";
 import { MigrationColumn, MigrationIndex } from "../types/types";
 

package/src/database/db.ts

@@ -1,32 +1,10 @@
 export type DBPreset = "w" | "r";
 import knex, { Knex } from "knex";
-import path from "path";
-import _ from "lodash";
+import * as _ from "lodash-es";
 import { Sonamu } from "../api";
-import { ServiceUnavailableException } from "../exceptions/so-exceptions";
 import { AsyncLocalStorage } from "async_hooks";
 import { TransactionContext } from "./transaction-context";
-
-type MySQLConfig = Omit<Knex.Config, "connection"> & {
-  connection?: Knex.MySql2ConnectionConfig;
-};
-
-export type SonamuDBBaseConfig = {
-  // 기본 데이터베이스 이름
-  database: string;
-
-  // 모든 환경에 적용될 기본 Knex 옵션
-  defaultOptions?: MySQLConfig;
-
-  // 환경별 설정
-  environments?: {
-    development?: MySQLConfig;
-    development_slave?: MySQLConfig;
-    production?: MySQLConfig;
-    production_slave?: MySQLConfig;
-    remote_fixture?: MySQLConfig;
-  };
-};
+import { DatabaseConfig, SonamuConfig } from "../api/config";
 
 export type SonamuDBConfig = {
   development_master: Knex.Config;
@@ -52,25 +30,6 @@ class DBClass {
     return this.transactionStorage.getStore() ?? new TransactionContext();
   }
 
-  async readKnexfile(): Promise<SonamuDBConfig> {
-    const dbConfigPath: string = path.join(
-      Sonamu.apiRootPath,
-      "/dist/configs/db.js"
-    );
-    try {
-      const knexfileModule = await import(dbConfigPath);
-      const config =
-        knexfileModule.default?.default ??
-        knexfileModule.default ??
-        knexfileModule;
-      return this.generateDBConfig(config);
-    } catch {}
-
-    throw new ServiceUnavailableException(
-      `다음 경로에서 DB설정 파일을 찾을 수 없습니다: ${dbConfigPath}. 먼저 빌드(yarn build)를 수행해주세요.`
-    );
-  }
-
   getDB(which: DBPreset): Knex {
     const dbConfig = Sonamu.dbConfig;
 
@@ -134,8 +93,8 @@ class DBClass {
     }
   }
 
-  private generateDBConfig(config: SonamuDBBaseConfig): SonamuDBConfig {
-    const defaultKnexConfig: Partial<MySQLConfig> = _.merge(
+  public generateDBConfig(config: SonamuConfig["database"]): SonamuDBConfig {
+    const defaultKnexConfig: Partial<DatabaseConfig> = _.merge(
       {
         client: "mysql2",
         pool: {
@@ -143,11 +102,10 @@ class DBClass {
           max: 5,
         },
         migrations: {
-          extension: "js",
-          directory: "./dist/migrations",
+          directory: "./src/migrations",
         },
         connection: {
-          database: config.database,
+          database: config.name,
           ...config.defaultOptions?.connection,
         },
       },
@@ -155,16 +113,16 @@ class DBClass {
     );
 
     // 로컬 환경 설정
-    const test: MySQLConfig = _.merge({}, defaultKnexConfig, {
+    const test: DatabaseConfig = _.merge({}, defaultKnexConfig, {
       connection: {
-        database: `${config.database}_test`,
+        database: `${config.name}_test`,
         ...config.defaultOptions?.connection,
       },
     });
 
     const fixture_local = _.merge({}, defaultKnexConfig, {
       connection: {
-        database: `${config.database}_fixture_local`,
+        database: `${config.name}_fixture_local`,
         ...config.defaultOptions?.connection,
       },
     });
@@ -186,7 +144,7 @@ class DBClass {
       devMasterOptions,
       {
         connection: {
-          database: `${config.database}_fixture_remote`,
+          database: `${config.name}_fixture_remote`,
         },
       },
       config.environments?.remote_fixture

package/src/database/puri.ts

@@ -15,13 +15,9 @@ import type {
 } from "./puri.types";
 import chalk from "chalk";
 import assert from "assert";
+import { Naite } from "../naite/naite";
 
-export class Puri<
-  TSchema,
-  TTables extends Record<string, any>,
-  TResult,
-  TResolved = Expand<TResult>[],
-> {
+export class Puri<TSchema, TTables extends Record<string, any>, TResult> {
   private knexQuery: Knex.QueryBuilder;
 
   // 생성자 시그니처들
@@ -31,7 +27,7 @@ export class Puri<
     tableSpec: Record<string, string | Puri<TSchema, any, any>>
   );
   constructor(
-    private knex: Knex,
+    public knex: Knex,
     tableNameOrSpec: any
   ) {
     if (typeof tableNameOrSpec === "string") {
@@ -129,7 +125,7 @@ export class Puri<
     return { _type: "sql_expression", _return: "date", _sql: sql };
   }
 
-  // SELECT
+  // SELECT (overwrite)
   select<TSelect extends SelectObject<TTables>>(
     selectObj: TSelect
   ): Puri<TSchema, TTables, ParseSelectObject<TTables, TSelect>> {
@@ -161,6 +157,13 @@ export class Puri<
     return this as any;
   }
 
+  // SELECT (select는 overwrite, appendSelect는 append)
+  appendSelect<TSelect extends SelectObject<TTables>>(
+    selectObj: TSelect
+  ): Puri<TSchema, TTables, TResult & ParseSelectObject<TTables, TSelect>> {
+    return this.select(selectObj) as any;
+  }
+
   // SELECT *
   selectAll(): this {
     this.knexQuery.select("*");
@@ -354,7 +357,7 @@ export class Puri<
   // WHERE: 컬럼 - 사용: .where("u.id", ">", 10)
   where<TColumn extends AvailableColumns<TTables>>(
     column: TColumn,
-    operator: ComparisonOperator,
+    operator: ComparisonOperator | "like" | "not like",
     value: ExtractColumnType<TTables, TColumn & string>
   ): this;
   // WHERE: 컬럼 - 사용: .where("u.id", "like", "%test%")
@@ -479,101 +482,86 @@ export class Puri<
   }
 
   // 실행 메서드들 - thenable 구현
-  then<TResult1 = TResolved, TResult2 = never>(
+  then<TResult1 = Expand<TResult>[], TResult2 = never>(
     onfulfilled?:
-      | ((value: TResolved) => TResult1 | PromiseLike<TResult1>)
+      | ((value: Expand<TResult>[]) => TResult1 | PromiseLike<TResult1>)
       | null,
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
   ): Promise<TResult1 | TResult2> {
+    Naite.t("puri-query", this.toQuery());
     return this.knexQuery.then(onfulfilled as any, onrejected);
   }
   catch<TResult2 = never>(
     onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-  ): Promise<Expand<TResult> | TResult2> {
+  ): Promise<TResult | TResult2> {
     return this.knexQuery.catch(onrejected);
   }
-  finally(onfinally?: (() => void) | null): Promise<Expand<TResult>> {
+  finally(onfinally?: (() => void) | null): Promise<TResult> {
     return this.knexQuery.finally(onfinally);
   }
 
   // 하나만 쿼리
-  async first(): Promise<Expand<TResult> | undefined> {
-    return this.knexQuery.first();
-  }
-  // 하나만 쿼리 실패 시 에러
-  async firstOrFail(): Promise<TResult> {
-    const result = await this.knexQuery.first();
-    if (!result) {
-      throw new Error("No results found");
-    }
-    return result;
-  }
-
-  // 쿼리 후 인덱스 리턴
-  async at(index: number): Promise<Expand<TResult> | undefined> {
-    const results = (await this) as any[];
-    return results[index];
-  }
-  // 쿼리 후 인덱스 리턴 실패 시 에러
-  async assertAt(index: number): Promise<Expand<TResult>> {
-    const results = (await this) as any[];
-    const result = results[index];
-    if (result === undefined) {
-      throw new Error(`No result found at index ${index}`);
-    }
-    return result;
+  first(): ResolvedPuri<Expand<TResult>, never> {
+    this.knexQuery.first();
+    return new ResolvedPuri(this.knexQuery);
   }
 
   // 쿼리한 레코드에서 특정 컬럼만 추출한 배열 리턴
-  async pluck<TColumn extends ResultAvailableColumns<TTables, TResult>>(
+  pluck<
+    TColumn extends keyof TResult | ResultAvailableColumns<TTables, TResult>,
+  >(
     column: TColumn
-  ): Promise<ExtractColumnType<TTables, TColumn & string>[]> {
-    return this.knexQuery.pluck(column) as Promise<
-      ExtractColumnType<TTables, TColumn & string>[]
-    >;
+  ): ResolvedPuri<
+    TColumn extends keyof TResult
+      ? TResult[TColumn][]
+      : ExtractColumnType<TTables, TColumn & string>[],
+    never
+  > {
+    this.knexQuery.pluck(column as string);
+    return new ResolvedPuri(this.knexQuery);
   }
 
   // INSERT
   insert(
     data: InsertData<SingleTableValue<TTables>>
-  ): Puri<TSchema, {}, number, number[]> {
+  ): ResolvedPuri<[number], never> {
     this.knexQuery.insert(data);
-    return this as any;
+    return new ResolvedPuri(this.knexQuery);
   }
 
   // UPDATE
-  update(data: WhereCondition<TTables>): Puri<TSchema, {}, number, number> {
+  update(data: WhereCondition<TTables>): ResolvedPuri<TResult, number> {
     this.knexQuery.update(data);
-    return this as any;
+    return new ResolvedPuri(this.knexQuery);
   }
 
   // Increment
   increment<TColumn extends AvailableColumns<TTables>>(
     column: TColumn,
     value: number
-  ): this {
+  ): ResolvedPuri<number, never> {
     if (value <= 0) {
       throw new Error("Increment value must be greater than 0");
     }
     this.knexQuery.increment(column, value);
-    return this;
+    return new ResolvedPuri(this.knexQuery);
   }
   // Decrement
   decrement<TColumn extends AvailableColumns<TTables>>(
     column: TColumn,
     value: number
-  ): this {
+  ): ResolvedPuri<number, never> {
     if (value <= 0) {
       throw new Error("Decrement value must be greater than 0");
     }
     this.knexQuery.decrement(column, value);
-    return this;
+    return new ResolvedPuri(this.knexQuery);
   }
 
   // DELETE
-  delete(): Puri<TSchema, {}, number, number> {
+  delete(): ResolvedPuri<number, never> {
     this.knexQuery.delete();
-    return this as any;
+    return new ResolvedPuri(this.knexQuery);
   }
 
   // 확인 쿼리 리턴
@@ -800,3 +788,40 @@ export class JoinClauseGroup<
     return this;
   }
 }
+
+/*
+  TResolved: 쿼리 실행 후 반환될 결과 타입
+  _TReturning: 추후 RETURNING 절에 사용될 타입
+*/
+export class ResolvedPuri<TResolved, _TReturning> {
+  constructor(public knexQuery: Knex.QueryBuilder) {}
+
+  toQuery(): string {
+    return this.knexQuery.toQuery();
+  }
+
+  debug(): this {
+    console.log(
+      `${chalk.cyan("[Puri Debug]")} ${chalk.yellow(this.toQuery())}`
+    );
+    return this;
+  }
+
+  then<TResult1 = TResolved, TResult2 = never>(
+    onfulfilled?:
+      | ((value: TResolved) => TResult1 | PromiseLike<TResult1>)
+      | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2> {
+    Naite.t("puri-query", this.toQuery());
+    return this.knexQuery.then(onfulfilled as any, onrejected);
+  }
+  catch<TResult2 = never>(
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResolved | TResult2> {
+    return this.knexQuery.catch(onrejected);
+  }
+  finally(onfinally?: (() => void) | null): Promise<TResolved> {
+    return this.knexQuery.finally(onfinally);
+  }
+}