@fluojs/prisma 1.0.1 → 1.1.0

package/README.ko.md

@@ -2,7 +2,7 @@
 
 <p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
 
-fluo 애플리케이션을 위한 Prisma 라이프사이클 및 ALS 기반 트랜잭션 컨텍스트 모듈입니다. Prisma 클라이언트를 모듈 시스템에 연결하여 자동 연결 관리 및 요청 범위 트랜잭션을 제공합니다.
+fluo 애플리케이션을 위한 Prisma lifecycle 및 ALS 기반 transaction context입니다. `PrismaClient`를 모듈 시스템에 연결하고 자동 연결 관리와 요청 범위 트랜잭션을 제공합니다.
 
 ## 목차
 
@@ -10,10 +10,9 @@ fluo 애플리케이션을 위한 Prisma 라이프사이클 및 ALS 기반 트
 - [사용 시점](#사용-시점)
 - [빠른 시작](#빠른-시작)
 - [공통 패턴](#공통-패턴)
-  - [PrismaService와 current()](#prismaservice와-current)
+  - [서비스 트랜잭션 경계 (@Transaction)](#서비스-트랜잭션-경계-transaction)
   - [여러 클라이언트를 위한 이름 있는 등록](#여러-클라이언트를-위한-이름-있는-등록)
-  - [수동 트랜잭션](#수동-트랜잭션)
-  - [자동 요청 트랜잭션](#자동-요청-트랜잭션)
+  - [수동 트랜잭션과 current()](#수동-트랜잭션과-current)
   - [종료와 status 계약](#종료와-status-계약)
   - [비동기 설정과 격리](#비동기-설정과-격리)
   - [수동 모듈 조합](#수동-모듈-조합)
@@ -56,33 +55,52 @@ class AppModule {}
 
 ## 공통 패턴
 
-### PrismaService와 current()
+### 서비스 트랜잭션 경계 (@Transaction)
 
-`PrismaService`는 Prisma와 상호작용하는 기본 방법입니다. `current()` 메서드는 트랜잭션 범위 내에 있으면 자동으로 트랜잭션용 클라이언트를, 그렇지 않으면 루트 클라이언트를 반환합니다.
+`@Transaction()` 데코레이터는 서비스 레이어에서 트랜잭션 경계를 정의하는 권장 방법입니다. 이 데코레이터가 적용된 메서드 내부에서 발생하는 모든 리포지토리 호출은 동일한 Prisma 트랜잭션을 공유합니다.
 
 ```typescript
 import { Inject } from '@fluojs/core';
-import { PrismaService } from '@fluojs/prisma';
+import { PrismaService, Transaction, type PrismaServiceFacade } from '@fluojs/prisma';
 import { PrismaClient } from '@prisma/client';
+import { UserRepository } from './user.repository';
+
+export class UserService {
+  constructor(private readonly repo: UserRepository) {}
+
+  @Transaction()
+  async onboardUser(dto: CreateUserDto) {
+    const user = await this.repo.create(dto);
+    await this.repo.initProfile(user.id);
+    return user;
+  }
+}
 
 @Inject(PrismaService)
 export class UserRepository {
-  constructor(private readonly prisma: PrismaService<PrismaClient>) {}
+  constructor(private readonly prisma: PrismaServiceFacade<PrismaClient>) {}
+
+  async create(data: any) {
+    // facade 타입은 표준 PrismaClient delegate를 노출합니다.
+    // @Transaction() 내부에서 호출되면 자동으로 활성 트랜잭션에 참여합니다.
+    return this.prisma.user.create({ data });
+  }
 
-  async findById(id: string) {
-    // current()는 생성된 Prisma 타입과 자동완성을 그대로 유지합니다.
-    return this.prisma.current().user.findUnique({ where: { id } });
+  async initProfile(userId: string) {
+    return this.prisma.profile.create({ data: { userId } });
   }
 }
 ```
 
+`@Transaction()` 메서드 호출은 재진입(reentrant)이 가능합니다. 데코레이터가 적용된 메서드가 다른 데코레이터 적용 메서드를 호출하더라도 하나의 동일한 Prisma 트랜잭션 안에서 실행됩니다.
+
 ### 여러 클라이언트를 위한 이름 있는 등록
 
-하나의 애플리케이션 컨테이너 안에서 여러 Prisma Client가 필요하다면 각 등록에 명시적인 `name`을 부여하고 `getPrismaServiceToken(name)`으로 대응되는 토큰을 주입하세요.
+하나의 애플리케이션 컨테이너 안에서 여러 Prisma Client가 필요하다면 각 등록에 명시적인 `name`을 부여하고 `getPrismaServiceToken(name)`으로 대응되는 토큰을 주입하세요. 이름 있는 클라이언트를 사용할 때는 `@Transaction()`에 해당 서비스로 접근할 수 있는 accessor를 전달하세요.
 
 ```typescript
 import { Inject } from '@fluojs/core';
-import { PrismaModule, PrismaService, getPrismaServiceToken } from '@fluojs/prisma';
+import { PrismaModule, PrismaService, getPrismaServiceToken, Transaction, type PrismaServiceFacade } from '@fluojs/prisma';
 
 const usersPrismaModule = PrismaModule.forRoot({ name: 'users', client: usersPrisma });
 const analyticsPrismaModule = PrismaModule.forRoot({ name: 'analytics', client: analyticsPrisma });
@@ -90,55 +108,57 @@ const analyticsPrismaModule = PrismaModule.forRoot({ name: 'analytics', client:
 @Inject(getPrismaServiceToken('users'), getPrismaServiceToken('analytics'))
 export class MultiDatabaseService {
   constructor(
-    private readonly users: PrismaService<typeof usersPrisma>,
-    private readonly analytics: PrismaService<typeof analyticsPrisma>,
+    private readonly users: PrismaServiceFacade<typeof usersPrisma>,
+    private readonly analytics: PrismaServiceFacade<typeof analyticsPrisma>,
   ) {}
 
-  async loadDashboard(userId: string) {
-    const user = await this.users.current().user.findUnique({ where: { id: userId } });
-    const summary = await this.analytics.current().report.findMany();
-    return { summary, user };
+  @Transaction((self) => self.users)
+  async updateAndLog(userId: string, data: any) {
+    const user = await this.users.user.update({ where: { id: userId }, data });
+    // 이 호출은 'analytics'가 별도로 트랜잭션을 열지 않는 한 'users' 트랜잭션 밖에 있습니다.
+    await this.analytics.report.create({ data: { event: 'update', userId } });
+    return user;
   }
 }
 ```
 
-이름 없는 등록은 `PrismaService`, `PRISMA_CLIENT`, `PRISMA_OPTIONS`, `PrismaTransactionInterceptor`를 위한 기본 단일 클라이언트 경로로 유지됩니다. 같은 컨테이너에 여러 Prisma Client를 등록할 때는 토큰 해석이 명시적으로 유지되도록 추가 클라이언트마다 이름을 사용하세요.
-
-### 수동 트랜잭션
+### 수동 트랜잭션과 current()
 
-`prisma.transaction()`을 사용하여 대화형 트랜잭션 블록을 생성합니다. 블록 내부의 모든 `current()` 호출은 트랜잭션 범위의 클라이언트를 사용합니다.
+`PrismaService`는 트랜잭션 범위 내에 있으면 자동으로 트랜잭션용 클라이언트를, 그렇지 않으면 루트 클라이언트를 반환하는 `current()` 메서드를 제공합니다. 외부 라이브러리에 클라이언트를 전달하거나 복잡한 수동 트랜잭션 처리가 필요한 경우 escape hatch로 사용하세요.
 
 ```typescript
-await this.prisma.transaction(async () => {
-  const user = await this.prisma.current().user.create({ data });
-  await this.prisma.current().profile.create({ data: { userId: user.id } });
-});
-```
+import { Inject } from '@fluojs/core';
+import { PrismaService } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
 
-이미 활성 트랜잭션 컨텍스트가 있는 상태에서 `transaction()`을 호출하면 `PrismaService`는 중첩 Prisma 트랜잭션을 새로 열지 않고 활성 트랜잭션 클라이언트를 재사용합니다. 중첩 호출에는 isolation level 같은 트랜잭션 옵션을 전달하면 안 됩니다. 활성 컨텍스트에서 옵션을 제공하면 ambient transaction을 재사용하는 동안 호출자의 의도를 조용히 버리지 않도록 예외로 거부합니다.
+@Inject(PrismaService)
+export class AdvancedRepository {
+  constructor(private readonly prisma: PrismaService<PrismaClient>) {}
 
-### 자동 요청 트랜잭션
+  async customOperation() {
+    const tx = this.prisma.current();
+    // fluo가 자동으로 감싸지 않는 작업을 수행하거나, 
+    // PrismaClient를 직접 기대하는 외부 유틸리티에 전달할 때 tx를 사용하세요.
+    return tx.user.findMany();
+  }
+}
+```
 
-컨트롤러나 메서드에 `PrismaTransactionInterceptor`를 적용하면 전체 요청을 자동으로 트랜잭션으로 감쌉니다.
+수동 대화형 트랜잭션 블록에는 `prisma.transaction()`을 사용하세요:
 
 ```typescript
-import { Post, UseInterceptors } from '@fluojs/http';
-import { PrismaTransactionInterceptor } from '@fluojs/prisma';
-
-@UseInterceptors(PrismaTransactionInterceptor)
-class UserController {
-  @Post()
-  async create() {
-    // 이후 PrismaService.current()를 사용하는 모든 리포지토리 호출은 이 트랜잭션을 공유합니다.
-  }
-}
+await this.prisma.transaction(async () => {
+  const tx = this.prisma.current();
+  const user = await tx.user.create({ data });
+  await tx.profile.create({ data: { userId: user.id } });
+});
 ```
 
-`PrismaTransactionInterceptor`는 기본 이름 없는 `PrismaService`를 대상으로 합니다. 이름 있는 다중 클라이언트 등록에서는 해당 이름의 `PrismaService`를 주입한 뒤 필요한 위치에서 명시적으로 `transaction()` / `requestTransaction()` 경계를 여세요.
+이미 활성 트랜잭션 컨텍스트가 있는 상태에서 `transaction()`을 호출하면 `PrismaService`는 중첩 Prisma 트랜잭션을 새로 열지 않고 활성 트랜잭션 클라이언트를 재사용합니다. 중첩 호출에는 isolation level 같은 트랜잭션 옵션을 전달하면 안 됩니다. 활성 컨텍스트에서 옵션을 제공하면 ambient transaction을 재사용하는 동안 호출자의 의도를 조용히 버리지 않도록 예외로 거부합니다.
 
 ### 종료와 status 계약
 
-`PrismaService.requestTransaction(...)`은 정상 serving 전과 중에는 사용할 수 있지만, 애플리케이션 종료가 시작된 뒤에는 새 요청 범위 트랜잭션을 거부합니다. 종료 중에는 열린 요청 트랜잭션을 abort하고, 바깥 트랜잭션 경계가 settle될 때까지 추적한 뒤, 모두 drain한 다음 `$disconnect()`를 실행합니다. 기존 수동 `transaction(...)` 경계 안에서 열린 중첩 `requestTransaction(...)` 호출도 여기에 포함됩니다. 이 호출은 ambient Prisma transaction client를 재사용하고, 바깥 경계가 끝날 때까지 `details.activeRequestTransactions`에 남으며, 두 번째 Prisma 트랜잭션을 열지 않습니다.
+`PrismaService.requestTransaction(...)`은 정상 serving 전과 중에는 사용할 수 있지만, 애플리케이션 shutdown이 시작된 뒤에는 새 요청 범위 트랜잭션을 거부합니다. 종료 중에는 열린 요청 트랜잭션을 abort하고, 가장 바깥 transaction boundary가 settle될 때까지 추적한 다음 `$disconnect()` 실행 전에 drain합니다. 기존 수동 `transaction(...)` boundary 안에서 열린 중첩 `requestTransaction(...)` 호출도 동일합니다. 해당 호출은 ambient Prisma transaction client를 재사용하고, 바깥 boundary가 끝날 때까지 `details.activeRequestTransactions`에 표시되며, 두 번째 Prisma transaction을 열지 않습니다.
 
 `createPrismaPlatformStatusSnapshot(...)`와 `PrismaService.createPlatformStatusSnapshot()`은 같은 라이프사이클 계약을 진단 surface에 노출합니다.
 
@@ -167,13 +187,15 @@ PrismaModule.forRootAsync({
 
 하나의 컴파일된 애플리케이션 안에서는 하위 provider가 동일하게 resolve된 `PrismaService`, ALS 트랜잭션 컨텍스트, 라이프사이클 관리 대상 클라이언트를 공유합니다. 서로 다른 애플리케이션 컨테이너는 독립된 factory 결과를 받으므로 `$connect` / `$disconnect` 소유권과 요청 트랜잭션 상태가 격리됩니다.
 
+트랜잭션 경계에는 호스트가 제공하는 `AsyncLocalStorage` 지원이 필요합니다. `@fluojs/prisma`는 런타임이 노출하는 `globalThis.AsyncLocalStorage` 또는 Node.js의 `process.getBuiltinModule('node:async_hooks')` 호스트 경계를 통해 이를 resolve합니다. 두 경로 모두 사용할 수 없으면 동기 stack fallback으로 async boundary 사이의 `current()`를 잃는 대신, Prisma 트랜잭션을 열기 전에 `transaction()`과 `requestTransaction()`이 예외를 던집니다. 이 상태는 `createPlatformStatusSnapshot().details.transactionContext`에 `unavailable`로 보고됩니다.
+
 ### 수동 모듈 조합
 
 `PrismaModule.forRoot(...)` / `forRootAsync(...)`를 사용해 Prisma를 등록합니다. 커스텀 `defineModule(...)` 등록 안에서 Prisma 지원을 조합해야 할 때도 동일한 모듈 entrypoint를 import해서 사용하세요.
 
 ```typescript
 import { defineModule } from '@fluojs/runtime';
-import { PrismaModule, PrismaService, PrismaTransactionInterceptor } from '@fluojs/prisma';
+import { PrismaModule } from '@fluojs/prisma';
 import { PrismaClient } from '@prisma/client';
 
 const prisma = new PrismaClient();
@@ -181,7 +203,6 @@ const prisma = new PrismaClient();
 class ManualPrismaModule {}
 
 defineModule(ManualPrismaModule, {
-  exports: [PrismaService, PrismaTransactionInterceptor],
   imports: [PrismaModule.forRoot({ client: prisma })],
 });
 ```
@@ -196,7 +217,8 @@ defineModule(ManualPrismaModule, {
 - `forRootAsync(...)`는 애플리케이션 컨테이너마다 옵션을 한 번 resolve하여, 별도 bootstrap 사이에서 클라이언트 라이프사이클과 요청 트랜잭션 격리를 보존합니다.
 - `strictTransactions: true` 설정 시 트랜잭션 미지원 환경에서 즉시 예외를 발생시킵니다.
 - `strictTransactions`가 `false`이면 클라이언트가 interactive `$transaction`을 제공하지 않을 때 직접 실행으로 fallback합니다.
-- 이름 있는 등록의 `name`은 trim되며, 빈 이름은 거부됩니다.
+- sync 및 async 등록 모두에서 `client`는 실제 object/function handle이어야 하며, 누락된 handle은 모듈 등록 또는 async bootstrap 중 거부됩니다.
+- 이름 있는 등록의 `name`은 public token 생성 전에 trim되며, 빈 이름은 거부됩니다.
 
 ### `PrismaService<TClient>`
 
@@ -207,6 +229,12 @@ defineModule(ManualPrismaModule, {
 - `requestTransaction(fn, signal?, options?): Promise<T>`
   - HTTP 요청 라이프사이클에 특화된 트랜잭션 경계를 실행합니다. Abort를 인식하고, shutdown 중에는 disconnect 전에 열린 요청 트랜잭션을 drain하며, Prisma client가 `signal` 옵션을 거부하면 해당 옵션 없이 재시도합니다. `transaction()`과 마찬가지로 중첩 호출은 활성 트랜잭션 컨텍스트를 재사용하고, 트랜잭션 설정을 조용히 무시하지 않도록 중첩 옵션을 거부합니다.
 
+Provider가 `current()`, `transaction(...)`, `requestTransaction(...)`, `createPlatformStatusSnapshot()` 같은 wrapper 메서드만 필요로 한다면 `PrismaService<TClient>`를 사용하세요. 생성된 Prisma Client delegate를 직접 호출하는 repository 주입에는 `PrismaServiceFacade<TClient>`를 사용하세요. 이 facade는 활성 트랜잭션이 있으면 해당 트랜잭션 client로, 없으면 root client로 호출을 전달합니다. `PrismaService.createFacade(...)`는 module-provider wiring을 위한 저수준 compatibility helper로 유지되며, 애플리케이션 코드는 `PrismaModule.forRoot(...)` / `forRootAsync(...)`를 우선 사용해야 합니다.
+
+### `Transaction`
+
+- 서비스 계층 트랜잭션 경계를 위한 표준 TC39 method decorator입니다. 기본적으로 ambient `PrismaService`를 resolve하고, 이름 있는 client에는 accessor를 받을 수 있으며, 외부 경계에는 Prisma transaction option을 전달할 수 있습니다.
+
 ### `PRISMA_CLIENT` (Token)
 
 원시 `PrismaClient` 인스턴스를 위한 주입 토큰입니다.
@@ -234,6 +262,7 @@ defineModule(ManualPrismaModule, {
 - `PrismaModuleOptions`
 - `PrismaClientLike`
 - `PrismaHandleProvider`
+- `PrismaServiceFacade<TClient>`
 - `PrismaTransactionClient<TClient>`
 - `InferPrismaTransactionClient<TClient>`
 - `InferPrismaTransactionOptions<TClient>`
@@ -241,7 +270,7 @@ defineModule(ManualPrismaModule, {
 ## 관련 패키지
 
 - `@fluojs/runtime`: 애플리케이션 라이프사이클 훅을 관리합니다.
-- `@fluojs/http`: 인터셉터 시스템을 제공합니다.
+- `@fluojs/http`: 명시적 `requestTransaction(...)` 경계와 함께 사용할 수 있는 요청 라이프사이클 primitive를 제공합니다.
 - `@fluojs/terminus`: Prisma를 위한 헬스 인디케이터를 제공합니다.
 
 ## 예제 소스

package/README.md

@@ -10,10 +10,9 @@ Prisma lifecycle and ALS-backed transaction context for fluo applications. Conne
 - [When to Use](#when-to-use)
 - [Quick Start](#quick-start)
 - [Common Patterns](#common-patterns)
-  - [PrismaService and current()](#prismaservice-and-current)
+  - [Service Transaction Boundary (@Transaction)](#service-transaction-boundary-transaction)
   - [Named Registrations for Multiple Clients](#named-registrations-for-multiple-clients)
-  - [Manual Transactions](#manual-transactions)
-  - [Automatic Request Transactions](#automatic-request-transactions)
+  - [Manual Transactions and current()](#manual-transactions-and-current)
   - [Shutdown and Status Contracts](#shutdown-and-status-contracts)
   - [Async Configuration and Isolation](#async-configuration-and-isolation)
   - [Manual Module Composition](#manual-module-composition)
@@ -56,33 +55,52 @@ class AppModule {}
 
 ## Common Patterns
 
-### PrismaService and current()
+### Service Transaction Boundary (@Transaction)
 
-The `PrismaService` is the primary way to interact with Prisma. Its `current()` method automatically returns the active transaction client if inside a transaction scope, or the root client otherwise.
+The `@Transaction()` decorator is the recommended way to define transaction boundaries in your service layer. It ensures that all repository calls made within the decorated method share the same Prisma transaction.
 
 ```typescript
 import { Inject } from '@fluojs/core';
-import { PrismaService } from '@fluojs/prisma';
+import { PrismaService, Transaction, type PrismaServiceFacade } from '@fluojs/prisma';
 import { PrismaClient } from '@prisma/client';
+import { UserRepository } from './user.repository';
+
+export class UserService {
+  constructor(private readonly repo: UserRepository) {}
+
+  @Transaction()
+  async onboardUser(dto: CreateUserDto) {
+    const user = await this.repo.create(dto);
+    await this.repo.initProfile(user.id);
+    return user;
+  }
+}
 
 @Inject(PrismaService)
 export class UserRepository {
-  constructor(private readonly prisma: PrismaService<PrismaClient>) {}
+  constructor(private readonly prisma: PrismaServiceFacade<PrismaClient>) {}
+
+  async create(data: any) {
+    // The facade type exposes standard PrismaClient delegates.
+    // When called inside @Transaction(), they automatically participate in the ambient transaction.
+    return this.prisma.user.create({ data });
+  }
 
-  async findById(id: string) {
-    // current() preserves your generated Prisma types and autocomplete
-    return this.prisma.current().user.findUnique({ where: { id } });
+  async initProfile(userId: string) {
+    return this.prisma.profile.create({ data: { userId } });
   }
 }
 ```
 
+Calls to `@Transaction()` methods are reentrant. If a decorated method calls another decorated method, they share the same underlying Prisma transaction.
+
 ### Named Registrations for Multiple Clients
 
-When one application container needs more than one Prisma client, register each client with an explicit `name` and inject the matching token with `getPrismaServiceToken(name)`.
+When one application container needs more than one Prisma client, register each client with an explicit `name` and inject the matching token with `getPrismaServiceToken(name)`. For named clients, pass an accessor to `@Transaction()` to target the correct service.
 
 ```typescript
 import { Inject } from '@fluojs/core';
-import { PrismaModule, PrismaService, getPrismaServiceToken } from '@fluojs/prisma';
+import { PrismaModule, PrismaService, getPrismaServiceToken, Transaction, type PrismaServiceFacade } from '@fluojs/prisma';
 
 const usersPrismaModule = PrismaModule.forRoot({ name: 'users', client: usersPrisma });
 const analyticsPrismaModule = PrismaModule.forRoot({ name: 'analytics', client: analyticsPrisma });
@@ -90,51 +108,54 @@ const analyticsPrismaModule = PrismaModule.forRoot({ name: 'analytics', client:
 @Inject(getPrismaServiceToken('users'), getPrismaServiceToken('analytics'))
 export class MultiDatabaseService {
   constructor(
-    private readonly users: PrismaService<typeof usersPrisma>,
-    private readonly analytics: PrismaService<typeof analyticsPrisma>,
+    private readonly users: PrismaServiceFacade<typeof usersPrisma>,
+    private readonly analytics: PrismaServiceFacade<typeof analyticsPrisma>,
   ) {}
 
-  async loadDashboard(userId: string) {
-    const user = await this.users.current().user.findUnique({ where: { id: userId } });
-    const summary = await this.analytics.current().report.findMany();
-    return { summary, user };
+  @Transaction((self) => self.users)
+  async updateAndLog(userId: string, data: any) {
+    const user = await this.users.user.update({ where: { id: userId }, data });
+    // This call is outside the 'users' transaction unless 'analytics' also opens one
+    await this.analytics.report.create({ data: { event: 'update', userId } });
+    return user;
   }
 }
 ```
 
-Unnamed registration remains the default single-client path for `PrismaService`, `PRISMA_CLIENT`, `PRISMA_OPTIONS`, and `PrismaTransactionInterceptor`. When you register multiple Prisma clients in the same container, use names for every additional client so token resolution stays explicit.
 
-### Manual Transactions
+### Manual Transactions and current()
 
-Use `prisma.transaction()` to create an interactive transaction block. Any calls to `current()` inside the block will use the transaction-scoped client.
+The `PrismaService` provides a `current()` method that returns the active transaction client if inside a transaction scope, or the root client otherwise. Use this as an escape hatch when you need to pass the client to external libraries or perform advanced manual transaction plumbing.
 
 ```typescript
-await this.prisma.transaction(async () => {
-  const user = await this.prisma.current().user.create({ data });
-  await this.prisma.current().profile.create({ data: { userId: user.id } });
-});
-```
+import { Inject } from '@fluojs/core';
+import { PrismaService } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
 
-When `transaction()` is called while a transaction context is already active, `PrismaService` reuses the active transaction client instead of opening a nested Prisma transaction. Nested calls must not pass transaction options such as isolation levels; providing options in an active context is rejected so the package does not silently drop caller intent while reusing the ambient transaction.
+@Inject(PrismaService)
+export class AdvancedRepository {
+  constructor(private readonly prisma: PrismaService<PrismaClient>) {}
 
-### Automatic Request Transactions
+  async customOperation() {
+    const tx = this.prisma.current();
+    // Use tx for operations that fluo doesn't automatically wrap, 
+    // or when passing to an external utility that expects a PrismaClient.
+    return tx.user.findMany();
+  }
+}
+```
 
-Apply the `PrismaTransactionInterceptor` to a controller or method to wrap the entire request in a transaction automatically.
+Use `prisma.transaction()` for manual interactive transaction blocks:
 
 ```typescript
-import { Post, UseInterceptors } from '@fluojs/http';
-import { PrismaTransactionInterceptor } from '@fluojs/prisma';
-
-@UseInterceptors(PrismaTransactionInterceptor)
-class UserController {
-  @Post()
-  async create() {
-    // All downstream repository calls via PrismaService.current() share this tx
-  }
-}
+await this.prisma.transaction(async () => {
+  const tx = this.prisma.current();
+  const user = await tx.user.create({ data });
+  await tx.profile.create({ data: { userId: user.id } });
+});
 ```
 
-`PrismaTransactionInterceptor` targets the default unnamed `PrismaService`. For named multi-client registrations, inject the corresponding named `PrismaService` and open explicit `transaction()` / `requestTransaction()` boundaries where needed.
+When `transaction()` is called while a transaction context is already active, `PrismaService` reuses the active transaction client instead of opening a nested Prisma transaction. Nested calls must not pass transaction options such as isolation levels; providing options in an active context is rejected so the package does not silently drop caller intent while reusing the ambient transaction.
 
 ### Shutdown and Status Contracts
 
@@ -167,13 +188,15 @@ PrismaModule.forRootAsync({
 
 Within one compiled application, downstream providers share the same resolved `PrismaService`, ALS transaction context, and lifecycle-managed client. Separate application containers receive independent factory results, so `$connect` / `$disconnect` ownership and request transaction state remain isolated.
 
+Transaction boundaries require host-provided `AsyncLocalStorage` support. `@fluojs/prisma` resolves it through `globalThis.AsyncLocalStorage` when a runtime exposes one, or through the host's `process.getBuiltinModule('node:async_hooks')` boundary on Node.js. If neither path is available, `transaction()` and `requestTransaction()` reject before opening a Prisma transaction instead of using a synchronous stack fallback that would lose `current()` across async boundaries; `createPlatformStatusSnapshot().details.transactionContext` reports `unavailable` in that state.
+
 ### Manual Module Composition
 
 Use `PrismaModule.forRoot(...)` / `forRootAsync(...)` to register Prisma. When you need to compose Prisma support inside a custom `defineModule(...)` registration, import the module entrypoint there as well.
 
 ```typescript
 import { defineModule } from '@fluojs/runtime';
-import { PrismaModule, PrismaService, PrismaTransactionInterceptor } from '@fluojs/prisma';
+import { PrismaModule } from '@fluojs/prisma';
 import { PrismaClient } from '@prisma/client';
 
 const prisma = new PrismaClient();
@@ -181,7 +204,6 @@ const prisma = new PrismaClient();
 class ManualPrismaModule {}
 
 defineModule(ManualPrismaModule, {
-  exports: [PrismaService, PrismaTransactionInterceptor],
   imports: [PrismaModule.forRoot({ client: prisma })],
 });
 ```
@@ -196,7 +218,8 @@ defineModule(ManualPrismaModule, {
 - `forRootAsync(...)` resolves options once per application container, preserving client lifecycle and request transaction isolation across separate bootstraps.
 - Supports `strictTransactions: true` to throw if transaction support is missing.
 - When `strictTransactions` is `false`, PrismaService falls back to direct execution if the client does not expose interactive `$transaction`.
-- Names are trimmed for named registrations, and blank names are rejected.
+- `client` must be a concrete object/function handle for both sync and async registration; missing handles are rejected during module registration or async bootstrap.
+- Names are trimmed for named registrations, and blank names are rejected before public tokens are created.
 
 ### `PrismaService<TClient>`
 
@@ -207,6 +230,12 @@ defineModule(ManualPrismaModule, {
 - `requestTransaction(fn, signal?, options?): Promise<T>`
   - Specialized transaction boundary for HTTP request lifecycles. It is abort-aware, drains during shutdown before disconnect, and retries without `signal` when a Prisma client rejects that option. Like `transaction()`, nested calls reuse the active transaction context and reject nested options to avoid silently ignoring transaction settings.
 
+Use `PrismaService<TClient>` when a provider only needs wrapper methods such as `current()`, `transaction(...)`, `requestTransaction(...)`, or `createPlatformStatusSnapshot()`. Use `PrismaServiceFacade<TClient>` for repository injections that call generated Prisma Client delegates directly; the facade forwards those calls to the active transaction client when one exists and to the root client otherwise. `PrismaService.createFacade(...)` is retained as a low-level compatibility helper for module-provider wiring; application code should prefer `PrismaModule.forRoot(...)` / `forRootAsync(...)`.
+
+### `Transaction`
+
+- Standard TC39 method decorator for service-layer transaction boundaries. It resolves the ambient `PrismaService` by default, accepts an accessor for named clients, and can forward Prisma transaction options to the outer boundary.
+
 ### `PRISMA_CLIENT` (Token)
 
 Injectable token for the raw `PrismaClient` instance.
@@ -236,6 +265,7 @@ token are deliberately not exported.
 - `PrismaModuleOptions`
 - `PrismaClientLike`
 - `PrismaHandleProvider`
+- `PrismaServiceFacade<TClient>`
 - `PrismaTransactionClient<TClient>`
 - `InferPrismaTransactionClient<TClient>`
 - `InferPrismaTransactionOptions<TClient>`
@@ -243,7 +273,7 @@ token are deliberately not exported.
 ## Related Packages
 
 - `@fluojs/runtime`: Manages the application lifecycle hooks.
-- `@fluojs/http`: Provides the interceptor system.
+- `@fluojs/http`: Provides request lifecycle primitives that can be paired with explicit `requestTransaction(...)` boundaries.
 - `@fluojs/terminus`: Provides a health indicator for Prisma.
 
 ## Example Sources

package/dist/module.d.ts

@@ -1,4 +1,4 @@
-import { type AsyncModuleOptions } from '@fluojs/core';
+import type { AsyncModuleOptions } from '@fluojs/core';
 import { type ModuleType } from '@fluojs/runtime';
 import type { InferPrismaTransactionClient, InferPrismaTransactionOptions, PrismaClientLike, PrismaModuleOptions } from './types.js';
 type PrismaAsyncModuleOptions<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient, TTransactionOptions> = AsyncModuleOptions<Omit<PrismaModuleOptions<TClient, TTransactionClient, TTransactionOptions>, 'global' | 'name'>> & {
@@ -13,7 +13,7 @@ export declare class PrismaModule {
      * Registers Prisma providers from static options.
      *
      * @param options Prisma module options with client handle and strict transaction mode.
-     * @returns A module definition that exports `PrismaService` and `PrismaTransactionInterceptor`.
+     * @returns A module definition that exports `PrismaService` and related Prisma tokens.
      */
     static forRoot<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>>(options: PrismaModuleOptions<TClient, TTransactionClient, TTransactionOptions>): ModuleType;
     /**

package/dist/module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,kBAAkB,EAAc,MAAM,cAAc,CAAC;AAE3E,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAShE,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAapB,KAAK,wBAAwB,CAC3B,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,EAClB,mBAAmB,IACjB,kBAAkB,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG;IACvH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AA8KF;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CACZ,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,EAE5D,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,GAC7E,UAAU;IAIb;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CACjB,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,EAE5D,OAAO,EAAE,wBAAwB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,GAClF,UAAU;CAGd"}
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAS,MAAM,cAAc,CAAC;AAE9D,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAQhE,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAapB,KAAK,wBAAwB,CAC3B,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,EAClB,mBAAmB,IACjB,kBAAkB,CAAC,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,CAAC,GAAG;IACvH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAiMF;;GAEG;AACH,qBAAa,YAAY;IACvB;;;;;OAKG;IACH,MAAM,CAAC,OAAO,CACZ,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,EAE5D,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,GAC7E,UAAU;IAIb;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CACjB,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,EAE5D,OAAO,EAAE,wBAAwB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,GAClF,UAAU;CAGd"}

package/dist/module.js

@@ -1,13 +1,17 @@
-import { Inject } from '@fluojs/core';
 import { defineModule } from '@fluojs/runtime';
 import { PrismaService } from './service.js';
 import { getPrismaClientToken, getPrismaOptionsToken, getPrismaServiceToken } from './tokens.js';
-import { PrismaTransactionInterceptor } from './transaction.js';
 const PRISMA_NORMALIZED_OPTIONS = Symbol('fluo.prisma.normalized-options');
+function isObjectLike(value) {
+  return typeof value === 'object' && value !== null || typeof value === 'function';
+}
 function normalizePrismaRegistrationName(name) {
   if (name === undefined) {
     return undefined;
   }
+  if (typeof name !== 'string') {
+    throw new Error('PrismaModule name must be a string when provided.');
+  }
   const normalizedName = name.trim();
   if (normalizedName.length === 0) {
     throw new Error('PrismaModule name must be a non-empty string when provided.');
@@ -19,6 +23,9 @@ function getPrismaNormalizedOptionsToken(name) {
   return normalizedName === undefined ? PRISMA_NORMALIZED_OPTIONS : Symbol.for(`fluo.prisma.normalized-options:${normalizedName}`);
 }
 function normalizePrismaModuleOptions(options) {
+  if (!isObjectLike(options.client)) {
+    throw new Error('PrismaModule requires a client option.');
+  }
   return {
     name: normalizePrismaRegistrationName(options.name),
     client: options.client,
@@ -26,16 +33,12 @@ function normalizePrismaModuleOptions(options) {
     strictTransactions: options.strictTransactions ?? false
   };
 }
-function createNamedPrismaServiceProvider(name) {
-  const clientToken = getPrismaClientToken(name);
-  const optionsToken = getPrismaOptionsToken(name);
-  const serviceToken = getPrismaServiceToken(name);
-  class NamedPrismaService extends PrismaService {}
-  Inject(clientToken, optionsToken)(NamedPrismaService, {});
-  return [NamedPrismaService, {
-    provide: serviceToken,
-    useExisting: NamedPrismaService
-  }];
+function createPrismaServiceProvider(provide, clientToken, optionsToken) {
+  return {
+    inject: [clientToken, optionsToken],
+    provide,
+    useFactory: (client, serviceOptions) => PrismaService.createFacade(client, serviceOptions)
+  };
 }
 function createPrismaRuntimeProviders(normalizedOptionsProvider, name) {
   const normalizedOptionsToken = getPrismaNormalizedOptionsToken(name);
@@ -51,10 +54,10 @@ function createPrismaRuntimeProviders(normalizedOptionsProvider, name) {
     useFactory: options => ({
       strictTransactions: options.strictTransactions
     })
-  }, ...(name === undefined ? [PrismaService, {
+  }, ...(name === undefined ? [createPrismaServiceProvider(PrismaService, clientToken, optionsToken), {
     provide: getPrismaServiceToken(),
     useExisting: PrismaService
-  }, PrismaTransactionInterceptor] : createNamedPrismaServiceProvider(name))];
+  }] : [createPrismaServiceProvider(getPrismaServiceToken(name), clientToken, optionsToken)])];
 }
 function buildPrismaModule(options) {
   class PrismaRootModuleDefinition {}
@@ -63,7 +66,7 @@ function buildPrismaModule(options) {
     throw new Error('Named Prisma registrations are scoped and cannot be registered globally.');
   }
   return defineModule(PrismaRootModuleDefinition, {
-    exports: normalizedOptions.name === undefined ? [PrismaService, PrismaTransactionInterceptor, getPrismaServiceToken(), getPrismaClientToken(), getPrismaOptionsToken()] : [getPrismaServiceToken(normalizedOptions.name), getPrismaClientToken(normalizedOptions.name), getPrismaOptionsToken(normalizedOptions.name)],
+    exports: normalizedOptions.name === undefined ? [PrismaService, getPrismaServiceToken(), getPrismaClientToken(), getPrismaOptionsToken()] : [getPrismaServiceToken(normalizedOptions.name), getPrismaClientToken(normalizedOptions.name), getPrismaOptionsToken(normalizedOptions.name)],
     global: normalizedOptions.name === undefined ? normalizedOptions.global : false,
     providers: createPrismaRuntimeProviders({
       provide: getPrismaNormalizedOptionsToken(normalizedOptions.name),
@@ -92,7 +95,7 @@ function buildPrismaModuleAsync(options) {
     }
   };
   return defineModule(PrismaAsyncModuleDefinition, {
-    exports: normalizedName === undefined ? [PrismaService, PrismaTransactionInterceptor, getPrismaServiceToken(), getPrismaClientToken(), getPrismaOptionsToken()] : [getPrismaServiceToken(normalizedName), getPrismaClientToken(normalizedName), getPrismaOptionsToken(normalizedName)],
+    exports: normalizedName === undefined ? [PrismaService, getPrismaServiceToken(), getPrismaClientToken(), getPrismaOptionsToken()] : [getPrismaServiceToken(normalizedName), getPrismaClientToken(normalizedName), getPrismaOptionsToken(normalizedName)],
     global: normalizedName === undefined ? options.global ?? false : false,
     providers: createPrismaRuntimeProviders(normalizedOptionsProvider, normalizedName)
   });
@@ -106,7 +109,7 @@ export class PrismaModule {
    * Registers Prisma providers from static options.
    *
    * @param options Prisma module options with client handle and strict transaction mode.
-   * @returns A module definition that exports `PrismaService` and `PrismaTransactionInterceptor`.
+   * @returns A module definition that exports `PrismaService` and related Prisma tokens.
    */
   static forRoot(options) {
     return buildPrismaModule(options);

package/dist/service.d.ts

@@ -18,6 +18,20 @@ export declare class PrismaService<TClient extends PrismaClientLike<TTransaction
     private transactionAbortSignalSupport;
     private lifecycleState;
     constructor(client: TClient, serviceOptions?: PrismaServiceOptions);
+    /**
+     * Creates the low-level DI facade that forwards unknown Prisma API properties to the ambient `current()` client.
+     *
+     * @remarks
+     * This compatibility helper is used by `PrismaModule` provider wiring. Application code should prefer
+     * `PrismaModule.forRoot(...)` or `PrismaModule.forRootAsync(...)`, then type injected repository handles as
+     * `PrismaServiceFacade<TClient>` when direct generated Prisma delegates are needed.
+     *
+     * @param client Root Prisma client registered in the module.
+     * @param serviceOptions Runtime transaction options consumed by the Fluo wrapper.
+     * @returns A transaction-aware facade that exposes wrapper methods plus the root Prisma client surface.
+     */
+    static createFacade<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>>(client: TClient, serviceOptions?: PrismaServiceOptions): PrismaServiceFacade<TClient, TTransactionClient, TTransactionOptions>;
+    private installCurrentClientFacade;
     /**
      * Returns the active Prisma handle for the current async context.
      *
@@ -80,6 +94,7 @@ export declare class PrismaService<TClient extends PrismaClientLike<TTransaction
     private runWithRequestTransactionClient;
     private runNestedRequestTransaction;
     private assertRequestTransactionsAvailable;
+    private assertTransactionContextAvailable;
     private throwIfRequestAborted;
     private runRequestTransactionWithAbortSignal;
     private canAttemptTransactionAbortSignalOption;
@@ -90,5 +105,18 @@ export declare class PrismaService<TClient extends PrismaClientLike<TTransaction
     private trackActiveRequestTransaction;
     private untrackActiveRequestTransaction;
 }
+/**
+ * Injection-facing Prisma facade type that combines the Fluo wrapper methods with the registered Prisma client surface.
+ *
+ * @remarks
+ * `PrismaModule` resolves `PrismaService` to a facade that forwards unknown properties to `current()`. Use this type in
+ * repositories that call generated Prisma delegates directly, and use `PrismaService<TClient>` when only wrapper methods
+ * (`current()`, `transaction(...)`, `requestTransaction(...)`, and status snapshots) are needed.
+ *
+ * @typeParam TClient Root Prisma client shape registered in the module.
+ * @typeParam TTransactionClient Transaction-scoped client resolved inside `$transaction(...)` callbacks.
+ * @typeParam TTransactionOptions Options forwarded to Prisma interactive transactions.
+ */
+export type PrismaServiceFacade<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>> = PrismaService<TClient, TTransactionClient, TTransactionOptions> & Omit<TClient, keyof PrismaService<TClient, TTransactionClient, TTransactionOptions>>;
 export {};
 //# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAK3E,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAMpB,UAAU,oBAAoB;IAC5B,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAoBD;;;;;;GAMG;AACH,qBACa,aAAa,CACxB,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,CAE5D,YAAW,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,EAAE,YAAY,EAAE,qBAAqB;IAQpH,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAPjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmE;IAChG,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,6BAA6B,CAA4C;IACjF,OAAO,CAAC,cAAc,CAAgE;gBAGnE,MAAM,EAAE,OAAO,EACf,cAAc,GAAE,oBAAoD;IAGvF;;;;;;;;;OASG;IACH,OAAO,IAAI,OAAO,GAAG,kBAAkB;YAIzB,wBAAwB;IAuChC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ7B,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5C;;;;OAIG;IACH,4BAA4B;IAY5B;;;;;;;;;;;;;;;;;OAiBG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC;IAQrF;;;;;;;;;;;;;;;;;;OAkBG;IACG,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC;YAkCpG,+BAA+B;YAuB/B,2BAA2B;IAqCzC,OAAO,CAAC,kCAAkC;IAM1C,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,oCAAoC;IAY5C,OAAO,CAAC,sCAAsC;YAYhC,qCAAqC;IAyBnD,OAAO,CAAC,6BAA6B;IAUrC,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,0BAA0B;IAWlC,OAAO,CAAC,6BAA6B;IAIrC,OAAO,CAAC,+BAA+B;CAGxC"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAK3E,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAQpB,UAAU,oBAAoB;IAC5B,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AA6GD;;;;;;GAMG;AACH,qBACa,aAAa,CACxB,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,CAE5D,YAAW,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,EAAE,YAAY,EAAE,qBAAqB;IAQpH,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAPjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuD;IACpF,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,6BAA6B,CAA4C;IACjF,OAAO,CAAC,cAAc,CAAgE;gBAGnE,MAAM,EAAE,OAAO,EACf,cAAc,GAAE,oBAAoD;IAKvF;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,YAAY,CACjB,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,EAE5D,MAAM,EAAE,OAAO,EACf,cAAc,GAAE,oBAAoD,GACnE,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC;IAMxE,OAAO,CAAC,0BAA0B;IAkBlC;;;;;;;;;OASG;IACH,OAAO,IAAI,OAAO,GAAG,kBAAkB;YAIzB,wBAAwB;IAyChC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ7B,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5C;;;;OAIG;IACH,4BAA4B;IAa5B;;;;;;;;;;;;;;;;;OAiBG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC;IAQrF;;;;;;;;;;;;;;;;;;OAkBG;IACG,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC;YAkCpG,+BAA+B;YAyB/B,2BAA2B;IAqCzC,OAAO,CAAC,kCAAkC;IAM1C,OAAO,CAAC,iCAAiC;IAMzC,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,oCAAoC;IAY5C,OAAO,CAAC,sCAAsC;YAYhC,qCAAqC;IAyBnD,OAAO,CAAC,6BAA6B;IAUrC,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,0BAA0B;IAWlC,OAAO,CAAC,6BAA6B;IAIrC,OAAO,CAAC,+BAA+B;CAGxC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,CAC7B,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC,IAC1D,aAAa,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,GACjE,IAAI,CAAC,OAAO,EAAE,MAAM,aAAa,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,CAAC,CAAC"}

package/dist/service.js

@@ -4,14 +4,61 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
 function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { createAbortError, createRequestAbortContext, raceWithAbort, trackActiveRequestTransaction, untrackActiveRequestTransaction } from '@fluojs/runtime';
 import { Inject } from '@fluojs/core';
 import { createPrismaPlatformStatusSnapshot } from './status.js';
 import { PRISMA_CLIENT, PRISMA_OPTIONS } from './tokens.js';
 const NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR = 'Nested Prisma transaction options are not supported because the active transaction context is reused.';
 const REQUEST_TRANSACTION_UNAVAILABLE_ERROR = 'Prisma request transactions are not available during shutdown.';
-let _PrismaService;
+const TRANSACTION_CONTEXT_UNAVAILABLE_ERROR = 'Prisma transaction context requires AsyncLocalStorage support from the host runtime.';
+function createCurrentClientPrismaFacade(target) {
+  return new Proxy(target, {
+    get(service, prop, receiver) {
+      if (prop in service) {
+        return Reflect.get(service, prop, receiver);
+      }
+      const currentClient = service.current();
+      const value = Reflect.get(currentClient, prop, currentClient);
+      return typeof value === 'function' ? value.bind(currentClient) : value;
+    }
+  });
+}
+class AsyncLocalStorageTransactionContextStore {
+  kind = 'als';
+  storage;
+  constructor(AsyncLocalStorage) {
+    this.storage = new AsyncLocalStorage();
+  }
+  getStore() {
+    return this.storage.getStore();
+  }
+  run(context, callback) {
+    return this.storage.run(context, callback);
+  }
+}
+class UnavailableTransactionContextStore {
+  kind = 'unavailable';
+  getStore() {
+    return undefined;
+  }
+  run(_context, _callback) {
+    throw new Error(TRANSACTION_CONTEXT_UNAVAILABLE_ERROR);
+  }
+}
+function resolveAsyncLocalStorageConstructor(host = globalThis) {
+  if (typeof host.AsyncLocalStorage === 'function') {
+    return host.AsyncLocalStorage;
+  }
+  return host.process?.getBuiltinModule?.('node:async_hooks').AsyncLocalStorage;
+}
+function createTransactionContextStore() {
+  const AsyncLocalStorage = resolveAsyncLocalStorageConstructor();
+  if (typeof AsyncLocalStorage === 'function') {
+    return new AsyncLocalStorageTransactionContextStore(AsyncLocalStorage);
+  }
+  return new UnavailableTransactionContextStore();
+}
+
 /**
  * Prisma runtime facade that owns lifecycle hooks and transaction context access.
  *
@@ -19,11 +66,12 @@ let _PrismaService;
  * @typeParam TTransactionClient Transaction-scoped client resolved inside `$transaction(...)` callbacks.
  * @typeParam TTransactionOptions Options forwarded to Prisma interactive transactions.
  */
+let _PrismaService;
 class PrismaService {
   static {
     [_PrismaService, _initClass] = _applyDecs(this, [Inject(PRISMA_CLIENT, PRISMA_OPTIONS)], []).c;
   }
-  transactions = new AsyncLocalStorage();
+  transactions = createTransactionContextStore();
   activeRequestTransactions = new Set();
   transactionAbortSignalSupport = 'unknown';
   lifecycleState = 'created';
@@ -32,6 +80,40 @@ class PrismaService {
   }) {
     this.client = client;
     this.serviceOptions = serviceOptions;
+    this.installCurrentClientFacade();
+  }
+
+  /**
+   * Creates the low-level DI facade that forwards unknown Prisma API properties to the ambient `current()` client.
+   *
+   * @remarks
+   * This compatibility helper is used by `PrismaModule` provider wiring. Application code should prefer
+   * `PrismaModule.forRoot(...)` or `PrismaModule.forRootAsync(...)`, then type injected repository handles as
+   * `PrismaServiceFacade<TClient>` when direct generated Prisma delegates are needed.
+   *
+   * @param client Root Prisma client registered in the module.
+   * @param serviceOptions Runtime transaction options consumed by the Fluo wrapper.
+   * @returns A transaction-aware facade that exposes wrapper methods plus the root Prisma client surface.
+   */
+  static createFacade(client, serviceOptions = {
+    strictTransactions: false
+  }) {
+    return createCurrentClientPrismaFacade(new _PrismaService(client, serviceOptions));
+  }
+  installCurrentClientFacade() {
+    for (const prop of Reflect.ownKeys(this.client)) {
+      if (prop in this) {
+        continue;
+      }
+      Object.defineProperty(this, prop, {
+        configurable: true,
+        get: () => {
+          const current = this.current();
+          const value = Reflect.get(current, prop);
+          return typeof value === 'function' ? value.bind(current) : value;
+        }
+      });
+    }
   }
 
   /**
@@ -60,6 +142,7 @@ class PrismaService {
       }
       return fn();
     }
+    this.assertTransactionContextAvailable();
     const deferredRequestTransactionHandles = new Set();
     try {
       return await run(transactionClient => this.transactions.run({
@@ -103,7 +186,8 @@ class PrismaService {
       supportsConnect: typeof this.client.$connect === 'function',
       supportsDisconnect: typeof this.client.$disconnect === 'function',
       supportsTransaction: typeof this.client.$transaction === 'function',
-      transactionAbortSignalSupport: this.transactionAbortSignalSupport
+      transactionAbortSignalSupport: this.transactionAbortSignalSupport,
+      transactionContext: this.transactions.kind
     });
   }
 
@@ -175,6 +259,7 @@ class PrismaService {
       }
       return fn();
     }
+    this.assertTransactionContextAvailable();
     return run(transactionClient => this.transactions.run({
       client: transactionClient,
       requestAbortSignal: signal
@@ -210,6 +295,11 @@ class PrismaService {
       throw new Error(REQUEST_TRANSACTION_UNAVAILABLE_ERROR);
     }
   }
+  assertTransactionContextAvailable() {
+    if (this.transactions.kind === 'unavailable') {
+      throw new Error(TRANSACTION_CONTEXT_UNAVAILABLE_ERROR);
+    }
+  }
   throwIfRequestAborted(signal) {
     if (signal.aborted) {
       throw createAbortError(signal.reason);
@@ -282,4 +372,17 @@ class PrismaService {
     _initClass();
   }
 }
+
+/**
+ * Injection-facing Prisma facade type that combines the Fluo wrapper methods with the registered Prisma client surface.
+ *
+ * @remarks
+ * `PrismaModule` resolves `PrismaService` to a facade that forwards unknown properties to `current()`. Use this type in
+ * repositories that call generated Prisma delegates directly, and use `PrismaService<TClient>` when only wrapper methods
+ * (`current()`, `transaction(...)`, `requestTransaction(...)`, and status snapshots) are needed.
+ *
+ * @typeParam TClient Root Prisma client shape registered in the module.
+ * @typeParam TTransactionClient Transaction-scoped client resolved inside `$transaction(...)` callbacks.
+ * @typeParam TTransactionOptions Options forwarded to Prisma interactive transactions.
+ */
 export { _PrismaService as PrismaService };

package/dist/status.d.ts

@@ -8,6 +8,7 @@ type PrismaPlatformStatusSnapshotInput = {
     supportsDisconnect: boolean;
     supportsTransaction: boolean;
     transactionAbortSignalSupport: 'unknown' | 'supported' | 'unsupported';
+    transactionContext?: 'als' | 'unavailable';
 };
 /**
  * Create prisma platform status snapshot.

package/dist/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EAGlC,MAAM,iBAAiB,CAAC;AAEzB,KAAK,4BAA4B,GAAG,SAAS,GAAG,OAAO,GAAG,eAAe,GAAG,SAAS,CAAC;AAEtF,KAAK,iCAAiC,GAAG;IACvC,yBAAyB,EAAE,MAAM,CAAC;IAClC,cAAc,EAAE,4BAA4B,CAAC;IAC7C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,eAAe,EAAE,OAAO,CAAC;IACzB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,6BAA6B,EAAE,SAAS,GAAG,WAAW,GAAG,aAAa,CAAC;CACxE,CAAC;AA6DF;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,iCAAiC,GACvC,iCAAiC,CAmBnC"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../src/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EAGlC,MAAM,iBAAiB,CAAC;AAEzB,KAAK,4BAA4B,GAAG,SAAS,GAAG,OAAO,GAAG,eAAe,GAAG,SAAS,CAAC;AAEtF,KAAK,iCAAiC,GAAG;IACvC,yBAAyB,EAAE,MAAM,CAAC;IAClC,cAAc,EAAE,4BAA4B,CAAC;IAC7C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,eAAe,EAAE,OAAO,CAAC;IACzB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,6BAA6B,EAAE,SAAS,GAAG,WAAW,GAAG,aAAa,CAAC;IACvE,kBAAkB,CAAC,EAAE,KAAK,GAAG,aAAa,CAAC;CAC5C,CAAC;AAqEF;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,iCAAiC,GACvC,iCAAiC,CAqBnC"}

package/dist/status.js

@@ -27,6 +27,13 @@ function createReadiness(input) {
       status: 'not-ready'
     };
   }
+  if (input.supportsTransaction && input.transactionContext === 'unavailable') {
+    return {
+      critical: true,
+      reason: 'Prisma transaction context requires AsyncLocalStorage support from the host runtime.',
+      status: 'not-ready'
+    };
+  }
   return {
     critical: true,
     status: 'ready'
@@ -57,6 +64,7 @@ function createHealth(input) {
  * @returns The create prisma platform status snapshot result.
  */
 export function createPrismaPlatformStatusSnapshot(input) {
+  const transactionContext = input.transactionContext ?? 'als';
   return {
     details: {
       activeRequestTransactions: input.activeRequestTransactions,
@@ -66,7 +74,7 @@ export function createPrismaPlatformStatusSnapshot(input) {
       supportsDisconnect: input.supportsDisconnect,
       supportsTransaction: input.supportsTransaction,
       transactionAbortSignalSupport: input.transactionAbortSignalSupport,
-      transactionContext: 'als'
+      transactionContext
     },
     health: createHealth(input),
     ownership: {

package/dist/transaction-decorator-contract.notes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TC39 standard method decorator — 2023-11 (Babel @babel/plugin-proposal-decorators)
+ * NO reflect-metadata. NO experimentalDecorators.
+ *
+ * Factory signature:
+ *   Transaction(accessor?) returns (value, context: ClassMethodDecoratorContext) => Function
+ *
+ * Default:    @Transaction()                         — uses `this` as the service
+ * Explicit:   @Transaction((self) => self.analytics) — uses returned service property
+ *
+ * Nested reuse: if active context exists, reuses it (no new transaction opened)
+ * Nested options: if active context exists AND options passed, THROWS
+ */
+export type TransactionAccessor<THost, TService> = (self: THost) => TService;
+/**
+ * Standard method decorator factory signature for Prisma service transaction boundaries.
+ */
+export type TransactionDecorator = <TService>(accessor?: TransactionAccessor<unknown, TService>) => (value: Function, context: ClassMethodDecoratorContext) => Function;
+//# sourceMappingURL=transaction-decorator-contract.notes.d.ts.map

package/dist/transaction-decorator-contract.notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-decorator-contract.notes.d.ts","sourceRoot":"","sources":["../src/transaction-decorator-contract.notes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,QAAQ,EAC1C,QAAQ,CAAC,EAAE,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,KAC9C,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,QAAQ,CAAC"}

package/dist/transaction-decorator-contract.notes.js

@@ -0,0 +1 @@
+export {};

package/dist/transaction.d.ts

@@ -1,25 +1,22 @@
-import type { Interceptor, InterceptorContext } from '@fluojs/http';
-import { PrismaService } from './service.js';
-import type { PrismaClientLike } from './types.js';
+type TransactionalPrismaService<TOptions = unknown> = {
+    transaction<T>(fn: () => Promise<T>, options?: TOptions): Promise<T>;
+};
+type TransactionAccessor<THost, TOptions> = (self: THost) => TransactionalPrismaService<TOptions>;
+type TransactionMethod<THost, TArgs extends unknown[], TResult> = (this: THost, ...args: TArgs) => Promise<TResult>;
 /**
- * HTTP interceptor that wraps a request handler in `PrismaService.requestTransaction(...)`.
+ * Wraps a service method in a `PrismaService.transaction(...)` boundary.
  *
  * @remarks
- * Pair this with repository/service code that reads `PrismaService.current()` so downstream calls share the same
- * request-scoped transaction client.
+ * This is a TC39 standard method decorator (2023-11) and does not use legacy decorator metadata or `reflect-metadata`.
+ * `@Transaction()` resolves a Prisma service from the decorated instance, while
+ * `@Transaction((self) => self.prisma)` selects an explicit service for named or multi-client registrations.
+ * Calls made while a transaction context is already active reuse the existing Prisma transaction through `PrismaService`.
+ * Passing Prisma transaction options to a nested call is rejected by `PrismaService.transaction(...)` so option intent is not
+ * silently ignored.
+ *
+ * @param input Optional service accessor or Prisma interactive transaction options.
+ * @returns A standard method decorator that runs the original method inside a Prisma transaction boundary.
  */
-export declare class PrismaTransactionInterceptor implements Interceptor {
-    private readonly prisma;
-    constructor(prisma: PrismaService<PrismaClientLike>);
-    /**
-     * Runs the downstream handler inside a Prisma request transaction boundary.
-     *
-     * @param context Interceptor context that supplies the request abort signal.
-     * @param next Downstream handler chain.
-     * @returns The downstream handler result after the request transaction settles.
-     */
-    intercept(context: InterceptorContext, next: {
-        handle(): Promise<unknown>;
-    }): Promise<unknown>;
-}
+export declare function Transaction<THost, TOptions = unknown>(input?: TransactionAccessor<THost, TOptions> | TOptions): <TArgs extends unknown[], TResult>(value: TransactionMethod<THost, TArgs, TResult>, context: ClassMethodDecoratorContext<THost, TransactionMethod<THost, TArgs, TResult>>) => TransactionMethod<THost, TArgs, TResult>;
+export {};
 //# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEpE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;GAMG;AACH,qBACa,4BAA6B,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa,CAAC,gBAAgB,CAAC;IAEpE;;;;;;OAMG;IACG,SAAS,CAAC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE;QAAE,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAGrG"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,KAAK,0BAA0B,CAAC,QAAQ,GAAG,OAAO,IAAI;IACpD,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACtE,CAAC;AAEF,KAAK,mBAAmB,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,0BAA0B,CAAC,QAAQ,CAAC,CAAC;AAElG,KAAK,iBAAiB,CAAC,KAAK,EAAE,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAChE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAwDtB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,EACnD,KAAK,CAAC,EAAE,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,GACtD,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EAClC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAC/C,OAAO,EAAE,2BAA2B,CAAC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,KAClF,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAiB5C"}

package/dist/transaction.js

@@ -1,39 +1,68 @@
-let _initClass;
-function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
-function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
-import { Inject } from '@fluojs/core';
-import { PrismaService } from './service.js';
-let _PrismaTransactionInt;
-/**
- * HTTP interceptor that wraps a request handler in `PrismaService.requestTransaction(...)`.
- *
- * @remarks
- * Pair this with repository/service code that reads `PrismaService.current()` so downstream calls share the same
- * request-scoped transaction client.
- */
-class PrismaTransactionInterceptor {
-  static {
-    [_PrismaTransactionInt, _initClass] = _applyDecs(this, [Inject(PrismaService)], []).c;
+function hasTransaction(value) {
+  return typeof value === 'object' && value !== null && 'transaction' in value && typeof value.transaction === 'function';
+}
+function readProperty(value, property) {
+  if (typeof value !== 'object' && typeof value !== 'function' || value === null) {
+    return undefined;
   }
-  constructor(prisma) {
-    this.prisma = prisma;
+  return Reflect.get(value, property);
+}
+function resolveDefaultPrismaService(self) {
+  const directPrisma = readProperty(self, 'prisma');
+  if (hasTransaction(directPrisma)) {
+    return directPrisma;
   }
-
-  /**
-   * Runs the downstream handler inside a Prisma request transaction boundary.
-   *
-   * @param context Interceptor context that supplies the request abort signal.
-   * @param next Downstream handler chain.
-   * @returns The downstream handler result after the request transaction settles.
-   */
-  async intercept(context, next) {
-    return this.prisma.requestTransaction(async () => next.handle(), context.requestContext.request.signal);
+  if (hasTransaction(self)) {
+    return self;
   }
-  static {
-    _initClass();
+  for (const value of Object.values(Object(self))) {
+    if (hasTransaction(value)) {
+      return value;
+    }
+    const nestedPrisma = readProperty(value, 'prisma');
+    if (hasTransaction(nestedPrisma)) {
+      return nestedPrisma;
+    }
   }
+  throw new Error('Unable to resolve PrismaService for @Transaction(). Provide an accessor function.');
 }
-export { _PrismaTransactionInt as PrismaTransactionInterceptor };
+function resolveTransactionInput(input) {
+  if (typeof input === 'function') {
+    return {
+      accessor: input
+    };
+  }
+  return {
+    options: input
+  };
+}
+
+/**
+ * Wraps a service method in a `PrismaService.transaction(...)` boundary.
+ *
+ * @remarks
+ * This is a TC39 standard method decorator (2023-11) and does not use legacy decorator metadata or `reflect-metadata`.
+ * `@Transaction()` resolves a Prisma service from the decorated instance, while
+ * `@Transaction((self) => self.prisma)` selects an explicit service for named or multi-client registrations.
+ * Calls made while a transaction context is already active reuse the existing Prisma transaction through `PrismaService`.
+ * Passing Prisma transaction options to a nested call is rejected by `PrismaService.transaction(...)` so option intent is not
+ * silently ignored.
+ *
+ * @param input Optional service accessor or Prisma interactive transaction options.
+ * @returns A standard method decorator that runs the original method inside a Prisma transaction boundary.
+ */
+export function Transaction(input) {
+  const {
+    accessor,
+    options
+  } = resolveTransactionInput(input);
+  return function transactionDecorator(value, context) {
+    if (context.kind !== 'method') {
+      throw new Error('@Transaction() can only decorate methods.');
+    }
+    return async function wrappedTransactionMethod(...args) {
+      const prisma = accessor?.(this) ?? resolveDefaultPrismaService(this);
+      return prisma.transaction(() => value.apply(this, args), options);
+    };
+  };
+}

package/package.json

@@ -9,7 +9,7 @@
     "transaction",
     "als"
   ],
-  "version": "1.0.1",
+  "version": "1.1.0",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -37,9 +37,9 @@
   ],
   "dependencies": {
     "@fluojs/core": "^1.0.3",
-    "@fluojs/http": "^1.1.0",
-    "@fluojs/di": "^1.0.3",
-    "@fluojs/runtime": "^1.1.1"
+    "@fluojs/http": "^1.1.2",
+    "@fluojs/di": "^1.1.0",
+    "@fluojs/runtime": "^1.1.8"
   },
   "peerDependencies": {
     "@prisma/client": ">=5.0.0"
@@ -51,7 +51,7 @@
   },
   "devDependencies": {
     "vitest": "^3.2.4",
-    "@fluojs/validation": "^1.0.4"
+    "@fluojs/validation": "^1.0.5"
   },
   "scripts": {
     "prebuild": "node ../../tooling/scripts/clean-dist.mjs",