sonamu 0.5.5 → 0.5.7

package/src/database/db.ts

@@ -74,6 +74,25 @@ class DBClass {
   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 +103,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(
@@ -163,11 +180,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.database}_fixture_remote`,
+        },
       },
-    }, config.environments?.remote_fixture);
+      config.environments?.remote_fixture
+    );
 
     // 프로덕션 환경 설정
     const prodMasterOptions = config.environments?.production ?? {};
@@ -190,5 +213,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);