sonamu 0.5.6 → 0.5.7

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);