sonamu 0.10.8 → 0.10.10

package/src/database/puri-wrapper.ts

@@ -99,11 +99,8 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
   ): Promise<T> {
     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,
@@ -112,33 +109,19 @@ export class PuriWrapper<TSchema extends DatabaseSchemaExtend = DatabaseSchemaEx
         async (trx) => {
           const trxWrapper = new PuriTransactionWrapper(trx, upsertBuilder);
 
-          // TransactionContext에 트랜잭션 저장
-          DB.getTransactionContext().setTransaction(dbPreset, trxWrapper);
-
-          try {
-            return await callback(trxWrapper);
-          } finally {
-            // 트랜잭션 제거
-            DB.getTransactionContext().deleteTransaction(dbPreset);
-          }
+          return DB.runWithTransactionScope(dbPreset, trxWrapper, () => callback(trxWrapper));
         },
         { isolationLevel: isolation, readOnly },
       );
     };
 
-    // AsyncLocalStorage 컨텍스트가 없으면 새로 생성
-    if (!existingContext) {
-      return DB.runWithTransaction(() => startTransaction(this.knex, this.upsertBuilder));
-    }
-
-    // 해당 preset의 트랜잭션이 이미 있으면 SAVEPOINT로 중첩 트랜잭션 생성
-    const existingTrx = existingContext.getTransaction(dbPreset);
+    const existingTrx = DB.transactionStorage.getStore()?.getTransaction(dbPreset);
     if (existingTrx) {
+      // 같은 preset의 중첩 트랜잭션은 기존 연결에서 SAVEPOINT로 시작한다.
       return startTransaction(existingTrx.trx, existingTrx.upsertBuilder);
-    } else {
-      // 컨텍스트는 있지만 이 preset의 트랜잭션은 없는 경우 (같은 컨텍스트 내에서 실행)
-      return startTransaction(this.knex, this.upsertBuilder);
     }
+
+    return startTransaction(this.knex, this.upsertBuilder);
   }
 
   ubRegister<TTable extends TableName<TSchema>>(

package/src/database/transaction-context.ts

@@ -2,17 +2,25 @@ import { type DBPreset } from "./db";
 import { type PuriTransactionWrapper } from "./puri-wrapper";
 
 export class TransactionContext {
-  private transactions: Map<DBPreset, PuriTransactionWrapper> = new Map();
+  constructor(
+    private readonly parent?: TransactionContext,
+    private local?: {
+      preset: DBPreset;
+      transaction: PuriTransactionWrapper;
+    },
+  ) {}
 
   getTransaction(preset: DBPreset): PuriTransactionWrapper | undefined {
-    return this.transactions.get(preset);
+    return this.local?.preset === preset
+      ? this.local.transaction
+      : this.parent?.getTransaction(preset);
   }
 
-  setTransaction(preset: DBPreset, trx: PuriTransactionWrapper): void {
-    this.transactions.set(preset, trx);
+  getActiveTransaction(): PuriTransactionWrapper | undefined {
+    return this.local?.transaction ?? this.parent?.getActiveTransaction();
   }
 
-  deleteTransaction(preset: DBPreset): void {
-    this.transactions.delete(preset);
+  clearLocal(): void {
+    this.local = undefined;
   }
 }

package/src/naite/naite-reporter.ts

@@ -6,6 +6,11 @@
  *
  * 프로젝트별로 고유한 소켓을 사용하기 위해 sonamu.config.ts 경로의 해시를 사용합니다.
  *
+ * 모듈 싱글턴이지만 인스턴스는 프로세스마다 별개입니다. run/start·run/end는
+ * Vitest 메인 프로세스(NaiteVitestReporter 커스텀 리포터)에서, test/result는
+ * 각 worker 프로세스(bootstrap의 afterEach)에서 전송되므로 buffer와 소켓
+ * 연결을 서로 공유하지 않습니다.
+ *
  * fs mock 충돌을 피하기 위해 net 모듈만 사용합니다.
  */
 /* oxlint-disable @typescript-eslint/no-explicit-any */ // Naite는 expect와 호응하도록 any를 허용함
@@ -112,7 +117,7 @@ class NaiteReporterClass {
   }
 
   /**
-   * beforeAll에서 호출합니다.
+   * Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunStart에서 호출합니다.
    * 테스트 run 시작을 알립니다 (데이터 클리어 신호).
    */
   async startTestRun(): Promise<void> {
@@ -127,7 +132,7 @@ class NaiteReporterClass {
   }
 
   /**
-   * afterEach에서 호출합니다.
+   * bootstrap()의 afterEach에서 호출합니다.
    * 테스트 케이스 결과를 traces와 함께 전송합니다.
    */
   async reportTestResult(
@@ -145,7 +150,7 @@ class NaiteReporterClass {
   }
 
   /**
-   * afterAll에서 호출합니다.
+   * Vitest 커스텀 리포터(NaiteVitestReporter)의 onTestRunEnd에서 호출합니다.
    * 테스트 run 종료를 알립니다.
    */
   async endTestRun(): Promise<void> {

package/src/template/__tests__/services.template.mutation.test.ts

@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { Sonamu } from "../../api";
+import { type ExtendedApi } from "../../api/decorators";
+import { Template__services } from "../implementations/services.template";
+
+describe("Template__services mutation hooks", () => {
+  let originalConfig: unknown;
+  let originalSyncer: unknown;
+
+  beforeEach(() => {
+    originalConfig = Reflect.get(Sonamu, "_config");
+    originalSyncer = Reflect.get(Sonamu, "_syncer");
+    Reflect.set(Sonamu, "_config", {
+      api: {
+        route: {
+          prefix: "/api",
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    Reflect.set(Sonamu, "_config", originalConfig);
+    Reflect.set(Sonamu, "_syncer", originalSyncer);
+  });
+
+  const renderServices = (apis: ExtendedApi[]) => {
+    Reflect.set(Sonamu, "_syncer", { apis });
+    return new Template__services().render({}).body;
+  };
+
+  it("파라미터가 있는 일반 mutation에서 namespace와 인자 순서를 유지한다", () => {
+    const body = renderServices([
+      {
+        modelName: "CaseModel",
+        methodName: "leave",
+        path: "/case/leave",
+        options: {
+          httpMethod: "POST",
+          clients: ["tanstack-mutation"],
+        },
+        typeParameters: [],
+        parameters: [
+          { name: "caseId", type: "number", optional: false },
+          { name: "notify", type: "boolean", optional: false },
+        ],
+        returnType: {
+          t: "ref",
+          id: "Promise",
+          args: ["boolean"],
+        },
+      },
+    ]);
+
+    expect(body).toContain(`export const useLeaveMutation = () => useMutation({
+  mutationFn: (params: { caseId: number, notify: boolean }) => CaseService.leave(params.caseId, params.notify)
+});`);
+    expect(body).not.toContain(
+      "mutationFn: (params: { caseId: number, notify: boolean }) => leave(params.caseId, params.notify)",
+    );
+  });
+
+  it("파라미터가 없는 일반 mutation에서 params: void 타입을 유지한다", () => {
+    const body = renderServices([
+      {
+        modelName: "CaseModel",
+        methodName: "refresh",
+        path: "/case/refresh",
+        options: {
+          httpMethod: "POST",
+          clients: ["tanstack-mutation"],
+        },
+        typeParameters: [],
+        parameters: [],
+        returnType: {
+          t: "ref",
+          id: "Promise",
+          args: ["void"],
+        },
+      },
+    ]);
+
+    expect(body).toContain(`export const useRefreshMutation = () => useMutation({
+  mutationFn: (params: void) => CaseService.refresh()
+});`);
+    expect(body).not.toContain("mutationFn: (params: void) => refresh()");
+  });
+
+  it("파일만 받는 multipart mutation에서 namespace와 mutation 옵션을 유지한다", () => {
+    const body = renderServices([
+      {
+        modelName: "VoiceFrame",
+        methodName: "uploadRecording",
+        path: "/voice/uploadRecording",
+        options: {
+          httpMethod: "POST",
+          clients: ["axios-multipart", "tanstack-mutation-multipart"],
+        },
+        typeParameters: [],
+        parameters: [],
+        returnType: {
+          t: "ref",
+          id: "Promise",
+          args: ["string"],
+        },
+      },
+    ]);
+
+    expect(body).toContain(`export const useUploadRecordingMutation = (
+  options?: UseMutationOptions<string, Error, { files: File[] }> & {
+    onUploadProgress?: (e: AxiosProgressEvent) => void;
+  }
+) => useMutation({
+  mutationFn: (params: { files: File[] }) => VoiceService.uploadRecording(params.files),
+  retry: false,
+  ...options,
+});`);
+    expect(body).not.toContain(
+      "mutationFn: (params: { files: File[] }) => uploadRecording(params.files)",
+    );
+  });
+
+  it("API 파라미터와 파일을 받는 multipart mutation에서 namespace와 인자 순서를 유지한다", () => {
+    const body = renderServices([
+      {
+        modelName: "VoiceFrame",
+        methodName: "transcript",
+        path: "/voice/transcript",
+        options: {
+          httpMethod: "POST",
+          clients: ["axios-multipart", "tanstack-mutation-multipart"],
+        },
+        typeParameters: [],
+        parameters: [
+          {
+            name: "params",
+            type: {
+              t: "object",
+              props: [
+                { name: "language", type: "string", optional: false },
+                { name: "speakerCount", type: "number", optional: false },
+              ],
+            },
+            optional: false,
+          },
+        ],
+        returnType: {
+          t: "ref",
+          id: "Promise",
+          args: ["number"],
+        },
+      },
+    ]);
+
+    expect(body).toContain(`export const useTranscriptMutation = (
+  options?: UseMutationOptions<number, Error, { params: { language: string, speakerCount: number }, files: File[] }> & {
+    onUploadProgress?: (e: AxiosProgressEvent) => void;
+  }
+) => useMutation({
+  mutationFn: (params: { params: { language: string, speakerCount: number }, files: File[] }) => VoiceService.transcript(params.params, params.files),
+  retry: false,
+  ...options,
+});`);
+    expect(body).not.toContain(
+      "mutationFn: (params: { params: { language: string, speakerCount: number }, files: File[] }) => transcript(params.params, params.files)",
+    );
+  });
+});

package/src/template/implementations/services.template.ts

@@ -353,7 +353,7 @@ export const ${infiniteHookName} = ${typeParamsDef}(${paramsDef}${
           functions.push(
             `
 export const use${hookName}Mutation = ${typeParamsDef}() => useMutation({
-  mutationFn: (params: ${mutationParamType}) => ${methodName}(${mutationParamNames})
+  mutationFn: (params: ${mutationParamType}) => ${modelName}Service.${methodName}(${mutationParamNames})
 });
           `.trim(),
           );
@@ -378,8 +378,8 @@ export const use${hookName}Mutation = ${typeParamsDef}() => useMutation({
           // mutationFn 호출 파라미터
           const mutationFnCall =
             paramsWithoutContext.length > 0
-              ? `${methodName}(params.params, params.files)`
-              : `${methodName}(params.files)`;
+              ? `${modelName}Service.${methodName}(params.params, params.files)`
+              : `${modelName}Service.${methodName}(params.files)`;
 
           functions.push(
             `