sonamu 0.5.6 → 0.6.0

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,28 +30,28 @@ 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;
 
+    // 테스트 트랜잭션 격리
+    if (process.env.NODE_ENV === "test") {
+      if (this.testTransaction) {
+        return this.testTransaction;
+      } else if (this.wdb) {
+        return this.wdb;
+      } else {
+        this["wdb"] = knex({
+          ...dbConfig["test"],
+          // 단일 풀
+          pool: {
+            min: 1,
+            max: 1,
+          },
+        });
+        return this["wdb"];
+      }
+    }
+
     const instanceName = which === "w" ? "wdb" : "rdb";
 
     if (!this[instanceName]) {
@@ -84,16 +62,14 @@ class DBClass {
           config =
             which === "w"
               ? dbConfig["development_master"]
-              : dbConfig["development_slave"] ?? dbConfig["development_master"];
+              : (dbConfig["development_slave"] ??
+                dbConfig["development_master"]);
           break;
         case "production":
           config =
             which === "w"
               ? dbConfig["production_master"]
-              : dbConfig["production_slave"] ?? dbConfig["production_master"];
-          break;
-        case "test":
-          config = dbConfig["test"];
+              : (dbConfig["production_slave"] ?? dbConfig["production_master"]);
           break;
         default:
           throw new Error(
@@ -117,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: {
@@ -126,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,
         },
       },
@@ -138,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,
       },
     });
@@ -163,11 +138,17 @@ class DBClass {
       devSlaveOptions
     );
     // NOTE: fixture remote는 default connection의 DB를 override해선 안됨.
-    const fixture_remote = _.merge({}, defaultKnexConfig, devMasterOptions, {
-      connection: {
-        database: `${config.database}_fixture_remote`,
+    const fixture_remote = _.merge(
+      {},
+      defaultKnexConfig,
+      devMasterOptions,
+      {
+        connection: {
+          database: `${config.name}_fixture_remote`,
+        },
       },
-    }, config.environments?.remote_fixture);
+      config.environments?.remote_fixture
+    );
 
     // 프로덕션 환경 설정
     const prodMasterOptions = config.environments?.production ?? {};
@@ -190,5 +171,17 @@ class DBClass {
       production_slave,
     };
   }
+
+  // Test 환경에서 트랜잭션 사용
+  public testTransaction: Knex.Transaction | null = null;
+  async createTestTransaction(): Promise<Knex.Transaction> {
+    const db = this.getDB("w");
+    this.testTransaction = await db.transaction();
+    return this.testTransaction;
+  }
+  async clearTestTransaction(): Promise<void> {
+    await this.testTransaction?.rollback();
+    this.testTransaction = null;
+  }
 }
 export const DB = new DBClass();

package/src/database/puri-wrapper.ts

@@ -5,8 +5,8 @@ import { DatabaseSchemaExtend } from "../types/types";
 import chalk from "chalk";
 import { DBPreset } from "./db";
 
-type TableName<DBSchema extends DatabaseSchemaExtend> = Extract<
-  keyof DBSchema,
+type TableName<TSchema extends DatabaseSchemaExtend> = Extract<
+  keyof TSchema,
   string
 >;
 
@@ -17,7 +17,7 @@ export type TransactionalOptions = {
 };
 
 export class PuriWrapper<
-  DBSchema extends DatabaseSchemaExtend = DatabaseSchemaExtend,
+  TSchema extends DatabaseSchemaExtend = DatabaseSchemaExtend,
 > {
   constructor(
     public knex: Knex,
@@ -27,60 +27,138 @@ export class PuriWrapper<
   raw(sql: string): Knex.Raw {
     return this.knex.raw(sql);
   }
-  // 기존: 테이블로 시작
-  table<TTable extends TableName<DBSchema>>(
+
+  // 테이블명으로 시작
+  from<TTable extends keyof TSchema>(
     tableName: TTable
-  ): Puri<DBSchema, TTable> {
-    return new Puri(this.knex, tableName as any);
+  ): Puri<
+    TSchema,
+    Record<TTable, TSchema[TTable]>,
+    Omit<TSchema[TTable], "__fulltext__">
+  >;
+  // 테이블명 + Alias로 시작
+  from<TTable extends keyof TSchema, TAlias extends string>(spec: {
+    [K in TAlias]: TTable;
+  }): Puri<
+    TSchema,
+    Record<TAlias, TSchema[TTable]>,
+    Omit<TSchema[TTable], "__fulltext__">
+  >;
+  // 서브쿼리로 시작
+  from<TAlias extends string, TSubResult>(spec: {
+    [K in TAlias]: Puri<TSchema, any, TSubResult>;
+  }): Puri<
+    TSchema,
+    Record<TAlias, TSubResult>,
+    Omit<TSubResult, "__fulltext__">
+  >;
+  from(spec: any): any {
+    return new Puri(this.knex, spec);
   }
 
-  // 새로 추가: 서브쿼리로 시작
-  fromSubquery<TSubResult, TAlias extends string>(
-    subquery: Puri<DBSchema, any, any, TSubResult, any>,
-    alias: TAlias extends string ? TAlias : never
-  ): Puri<DBSchema, TAlias, TSubResult, TSubResult, {}> {
-    return new Puri(this.knex, subquery, alias);
+  // 테이블명으로 시작
+  table<TTable extends keyof TSchema>(
+    tableName: TTable
+  ): Puri<
+    TSchema,
+    Record<TTable, TSchema[TTable]>,
+    Omit<TSchema[TTable], "__fulltext__">
+  >;
+  // 테이블명 + Alias로 시작
+  table<TTable extends keyof TSchema, TAlias extends string>(spec: {
+    [K in TAlias]: TTable;
+  }): Puri<
+    TSchema,
+    Record<TAlias, TSchema[TTable]>,
+    Omit<TSchema[TTable], "__fulltext__">
+  >;
+  // 서브쿼리로 시작
+  table<TAlias extends string, TSubResult>(spec: {
+    [K in TAlias]: Puri<TSchema, any, TSubResult>;
+  }): Puri<
+    TSchema,
+    Record<TAlias, TSubResult>,
+    Omit<TSubResult, "__fulltext__">
+  >;
+  table(spec: any): any {
+    return new Puri(this.knex, spec);
   }
 
   async transaction<T>(
     callback: (trx: PuriTransactionWrapper) => Promise<T>,
     options: TransactionalOptions = {}
   ): Promise<T> {
-    const { isolation, readOnly } = options;
+    const { isolation, readOnly, dbPreset = "w" } = options;
+
+    // @transactional 데코레이터와 동일한 로직: 이미 트랜잭션 컨텍스트가 있는지 확인
+    const { DB } = await import("./db");
+    const existingContext = DB.transactionStorage.getStore();
+
+    // AsyncLocalStorage 컨텍스트가 없거나 해당 preset의 트랜잭션이 없으면 새로 시작
+    const startTransaction = async (
+      knex: Knex | Knex.Transaction,
+      upsertBuilder: UpsertBuilder
+    ) => {
+      return knex.transaction(
+        async (trx) => {
+          const trxWrapper = new PuriTransactionWrapper(trx, upsertBuilder);
+
+          // TransactionContext에 트랜잭션 저장
+          DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);
+
+          try {
+            return await callback(trxWrapper);
+          } finally {
+            // 트랜잭션 제거
+            DB.getTransactionContext().deleteTransaction(dbPreset);
+          }
+        },
+        { isolationLevel: isolation, readOnly }
+      );
+    };
+
+    // AsyncLocalStorage 컨텍스트가 없으면 새로 생성
+    if (!existingContext) {
+      return DB.runWithTransaction(() =>
+        startTransaction(this.knex, this.upsertBuilder)
+      );
+    }
 
-    return this.knex.transaction(
-      async (trx) => {
-        return callback(new PuriTransactionWrapper(trx, this.upsertBuilder));
-      },
-      { isolationLevel: isolation, readOnly }
-    );
+    // 해당 preset의 트랜잭션이 이미 있으면 SAVEPOINT로 중첩 트랜잭션 생성
+    const existingTrx = existingContext.getTransaction(dbPreset);
+    if (existingTrx) {
+      return startTransaction(existingTrx.trx, existingTrx.upsertBuilder);
+    } else {
+      // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)
+      return startTransaction(this.knex, this.upsertBuilder);
+    }
   }
 
-  ubRegister<TTable extends TableName<DBSchema>>(
+  ubRegister<TTable extends TableName<TSchema>>(
     tableName: TTable,
     row: Partial<{
-      [K in keyof DBSchema[TTable]]: DBSchema[TTable][K] | UBRef;
+      [K in keyof TSchema[TTable]]: TSchema[TTable][K] | UBRef;
     }>
   ): UBRef {
     return this.upsertBuilder.register(tableName, row);
   }
 
   ubUpsert(
-    tableName: TableName<DBSchema>,
+    tableName: TableName<TSchema>,
     chunkSize?: number
   ): Promise<number[]> {
     return this.upsertBuilder.upsert(this.knex, tableName, chunkSize);
   }
 
   ubInsertOnly(
-    tableName: TableName<DBSchema>,
+    tableName: TableName<TSchema>,
     chunkSize?: number
   ): Promise<number[]> {
     return this.upsertBuilder.insertOnly(this.knex, tableName, chunkSize);
   }
 
   ubUpsertOrInsert(
-    tableName: TableName<DBSchema>,
+    tableName: TableName<TSchema>,
     mode: "upsert" | "insert",
     chunkSize?: number
   ): Promise<number[]> {
@@ -93,7 +171,7 @@ export class PuriWrapper<
   }
 
   ubUpdateBatch(
-    tableName: TableName<DBSchema>,
+    tableName: TableName<TSchema>,
     options?: { chunkSize?: number; where?: string | string[] }
   ): Promise<void> {
     return this.upsertBuilder.updateBatch(this.knex, tableName, options);