@fluojs/prisma 1.0.0-beta.4 → 1.0.0-beta.6

package/README.ko.md

@@ -14,6 +14,7 @@ fluo 애플리케이션을 위한 Prisma 라이프사이클 및 ALS 기반 트
   - [여러 클라이언트를 위한 이름 있는 등록](#여러-클라이언트를-위한-이름-있는-등록)
   - [수동 트랜잭션](#수동-트랜잭션)
   - [자동 요청 트랜잭션](#자동-요청-트랜잭션)
+  - [종료와 status 계약](#종료와-status-계약)
   - [비동기 설정과 격리](#비동기-설정과-격리)
   - [수동 모듈 조합](#수동-모듈-조합)
 - [공개 API 개요](#공개-api-개요)
@@ -114,6 +115,8 @@ await this.prisma.transaction(async () => {
 });
 ```
 
+이미 활성 트랜잭션 컨텍스트가 있는 상태에서 `transaction()`을 호출하면 `PrismaService`는 중첩 Prisma 트랜잭션을 새로 열지 않고 활성 트랜잭션 클라이언트를 재사용합니다. 중첩 호출에는 isolation level 같은 트랜잭션 옵션을 전달하면 안 됩니다. 활성 컨텍스트에서 옵션을 제공하면 ambient transaction을 재사용하는 동안 호출자의 의도를 조용히 버리지 않도록 예외로 거부합니다.
+
 ### 자동 요청 트랜잭션
 
 컨트롤러나 메서드에 `PrismaTransactionInterceptor`를 적용하면 전체 요청을 자동으로 트랜잭션으로 감쌉니다.
@@ -133,6 +136,18 @@ class UserController {
 
 `PrismaTransactionInterceptor`는 기본 이름 없는 `PrismaService`를 대상으로 합니다. 이름 있는 다중 클라이언트 등록에서는 해당 이름의 `PrismaService`를 주입한 뒤 필요한 위치에서 명시적으로 `transaction()` / `requestTransaction()` 경계를 여세요.
 
+### 종료와 status 계약
+
+`PrismaService.requestTransaction(...)`은 정상 serving 전과 중에는 사용할 수 있지만, 애플리케이션 종료가 시작된 뒤에는 새 요청 범위 트랜잭션을 거부합니다. 종료 중에는 열린 요청 트랜잭션을 abort하고, 바깥 트랜잭션 경계가 settle될 때까지 추적한 뒤, 모두 drain한 다음 `$disconnect()`를 실행합니다. 기존 수동 `transaction(...)` 경계 안에서 열린 중첩 `requestTransaction(...)` 호출도 여기에 포함됩니다. 이 호출은 ambient Prisma transaction client를 재사용하고, 바깥 경계가 끝날 때까지 `details.activeRequestTransactions`에 남으며, 두 번째 Prisma 트랜잭션을 열지 않습니다.
+
+`createPrismaPlatformStatusSnapshot(...)`와 `PrismaService.createPlatformStatusSnapshot()`은 같은 라이프사이클 계약을 진단 surface에 노출합니다.
+
+- `readiness.status`는 Prisma가 종료 중이거나 stopped 상태일 때, 그리고 `strictTransactions`가 켜져 있는데 `$transaction(...)`을 지원하지 않을 때 `not-ready`입니다.
+- `health.status`는 종료 중 요청 트랜잭션을 drain하는 동안 `degraded`, disconnect 이후 `unhealthy`입니다.
+- `details.activeRequestTransactions`, `details.lifecycleState`, `details.strictTransactions`, `details.supportsTransaction`, `details.transactionAbortSignalSupport`는 현재 요청 트랜잭션과 트랜잭션 capability 상태를 설명합니다.
+- `details.transactionContext: 'als'`는 요청 및 서비스 트랜잭션 경계가 사용하는 async-local transaction context를 식별합니다.
+- `ownership.externallyManaged: false`와 `ownership.ownsResources: true`는 패키지가 fluo 애플리케이션 라이프사이클 안에서 등록된 클라이언트의 `$connect()` / `$disconnect()` lifecycle hook을 소유한다는 의미입니다.
+
 ### 비동기 설정과 격리
 
 주입된 설정이나 다른 비동기 소스에서 Prisma 클라이언트를 만들어야 할 때는 `PrismaModule.forRootAsync(...)`를 사용하세요. 비동기 factory는 애플리케이션 컨테이너마다 한 번 resolve되며, 테스트나 여러 앱을 띄우는 프로세스에서 같은 모듈 정의를 재사용하더라도 별도 bootstrap 사이에서 공유되지 않습니다.
@@ -188,14 +203,19 @@ defineModule(ManualPrismaModule, {
 - `current(): TClient | PrismaTransactionClient<TClient>`
   - 현재 컨텍스트에 맞는 트랜잭션 클라이언트 또는 루트 클라이언트를 반환합니다.
 - `transaction(fn, options?): Promise<T>`
-  - 대화형 트랜잭션 내에서 함수를 실행합니다.
+  - 대화형 트랜잭션 내에서 함수를 실행합니다. 이미 트랜잭션 컨텍스트가 활성화되어 있으면 callback은 그 컨텍스트를 재사용하며, 새 Prisma 트랜잭션 경계가 열리지 않기 때문에 중첩 트랜잭션 옵션은 거부됩니다.
 - `requestTransaction(fn, signal?, options?): Promise<T>`
-  - HTTP 요청 라이프사이클에 특화된 트랜잭션 경계를 실행합니다. Abort를 인식하고, shutdown 중에는 disconnect 전에 열린 요청 트랜잭션을 drain하며, Prisma client가 `signal` 옵션을 거부하면 해당 옵션 없이 재시도합니다.
+  - HTTP 요청 라이프사이클에 특화된 트랜잭션 경계를 실행합니다. Abort를 인식하고, shutdown 중에는 disconnect 전에 열린 요청 트랜잭션을 drain하며, Prisma client가 `signal` 옵션을 거부하면 해당 옵션 없이 재시도합니다. `transaction()`과 마찬가지로 중첩 호출은 활성 트랜잭션 컨텍스트를 재사용하고, 트랜잭션 설정을 조용히 무시하지 않도록 중첩 옵션을 거부합니다.
 
 ### `PRISMA_CLIENT` (Token)
 
 원시 `PrismaClient` 인스턴스를 위한 주입 토큰입니다.
 
+### `PRISMA_OPTIONS` (Token)
+
+`PrismaService`가 소비하는 공개 런타임 옵션을 위한 주입 토큰이며, 현재 형태는 `{ strictTransactions: boolean }`입니다.
+이는 등록 identity, client ownership, visibility metadata까지 담는 패키지 내부 정규화 모듈 옵션 토큰보다 의도적으로 좁은 표면이며, 그 내부 토큰은 공개 API가 아닙니다.
+
 ### 플랫폼 status
 
 - `createPrismaPlatformStatusSnapshot(input)`: Prisma readiness, health, ownership, ALS 기반 transaction context를 보고하는 persistence platform status snapshot을 생성합니다.
@@ -207,6 +227,7 @@ defineModule(ManualPrismaModule, {
 - `getPrismaServiceToken(name?)`
 
 이 헬퍼들은 `name`이 없으면 기본 이름 없는 토큰을 반환하고, `name`이 있으면 해당 등록 전용 토큰을 반환합니다.
+이 헬퍼가 이름 있는 등록을 대상으로 삼는 공개 방법이며, 정규화 모듈 옵션 토큰 같은 내부 구현 토큰은 의도적으로 export하지 않습니다.
 
 ### 관련 export 타입
 

package/README.md

@@ -14,6 +14,7 @@ Prisma lifecycle and ALS-backed transaction context for fluo applications. Conne
   - [Named Registrations for Multiple Clients](#named-registrations-for-multiple-clients)
   - [Manual Transactions](#manual-transactions)
   - [Automatic Request Transactions](#automatic-request-transactions)
+  - [Shutdown and Status Contracts](#shutdown-and-status-contracts)
   - [Async Configuration and Isolation](#async-configuration-and-isolation)
   - [Manual Module Composition](#manual-module-composition)
 - [Public API Overview](#public-api-overview)
@@ -114,6 +115,8 @@ await this.prisma.transaction(async () => {
 });
 ```
 
+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.
+
 ### Automatic Request Transactions
 
 Apply the `PrismaTransactionInterceptor` to a controller or method to wrap the entire request in a transaction automatically.
@@ -133,6 +136,18 @@ class UserController {
 
 `PrismaTransactionInterceptor` targets the default unnamed `PrismaService`. For named multi-client registrations, inject the corresponding named `PrismaService` and open explicit `transaction()` / `requestTransaction()` boundaries where needed.
 
+### Shutdown and Status Contracts
+
+`PrismaService.requestTransaction(...)` is available before and during normal serving, but new request-scoped transactions are rejected once application shutdown has started. During shutdown, open request transactions are aborted, tracked until their outer transaction boundary has settled, and drained before `$disconnect()` runs. This includes nested `requestTransaction(...)` calls opened inside an existing manual `transaction(...)` boundary: they reuse the ambient Prisma transaction client, stay visible in `details.activeRequestTransactions` until the outer boundary finishes, and do not open a second Prisma transaction.
+
+`createPrismaPlatformStatusSnapshot(...)` and `PrismaService.createPlatformStatusSnapshot()` expose the same lifecycle contract to diagnostics surfaces:
+
+- `readiness.status` is `not-ready` while Prisma is shutting down or stopped, and when `strictTransactions` is enabled without `$transaction(...)` support.
+- `health.status` is `degraded` while request transactions are draining during shutdown and `unhealthy` after disconnect.
+- `details.activeRequestTransactions`, `details.lifecycleState`, `details.strictTransactions`, `details.supportsTransaction`, and `details.transactionAbortSignalSupport` describe the current request transaction and transaction-capability state.
+- `details.transactionContext: 'als'` identifies the async-local transaction context used by request and service transaction boundaries.
+- `ownership.externallyManaged: false` and `ownership.ownsResources: true` mean the package owns the registered client's `$connect()` / `$disconnect()` lifecycle hooks inside the fluo application lifecycle.
+
 ### Async Configuration and Isolation
 
 Use `PrismaModule.forRootAsync(...)` when the Prisma client must be created from injected configuration or another async source. The async factory is resolved once per application container and is not shared across separate bootstraps, even when the same module definition is reused in tests or multi-app processes.
@@ -188,14 +203,20 @@ defineModule(ManualPrismaModule, {
 - `current(): TClient | PrismaTransactionClient<TClient>`
   - Returns the ambient transaction client or the root client.
 - `transaction(fn, options?): Promise<T>`
-  - Runs a function within an interactive transaction.
+  - Runs a function within an interactive transaction. If a transaction context is already active, the callback reuses that context; nested transaction options are rejected because no new Prisma transaction boundary is opened.
 - `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.
+  - 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.
 
 ### `PRISMA_CLIENT` (Token)
 
 Injectable token for the raw `PrismaClient` instance.
 
+### `PRISMA_OPTIONS` (Token)
+
+Injectable token for the public runtime options consumed by `PrismaService`, currently `{ strictTransactions: boolean }`.
+This is intentionally narrower than the package's internal normalized module-options token, which also carries registration
+identity, client ownership, and visibility metadata and is not part of the public API.
+
 ### Platform status
 
 - `createPrismaPlatformStatusSnapshot(input)`: Creates a persistence platform status snapshot that reports Prisma readiness, health, ownership, and ALS-backed transaction context.
@@ -207,6 +228,8 @@ Injectable token for the raw `PrismaClient` instance.
 - `getPrismaServiceToken(name?)`
 
 These helpers return the default unnamed token when `name` is omitted and a registration-specific token when `name` is provided.
+They are the public way to target named registrations; internal implementation tokens such as the normalized module-options
+token are deliberately not exported.
 
 ### Related exported types
 

package/dist/service.d.ts

@@ -77,6 +77,10 @@ export declare class PrismaService<TClient extends PrismaClientLike<TTransaction
      * error type/message depends on the runtime abort implementation.
      */
     requestTransaction<T>(fn: () => Promise<T>, signal?: AbortSignal, options?: TTransactionOptions): Promise<T>;
+    private runWithRequestTransactionClient;
+    private runNestedRequestTransaction;
+    private assertRequestTransactionsAvailable;
+    private throwIfRequestAborted;
     private runRequestTransactionWithAbortSignal;
     private canAttemptTransactionAbortSignalOption;
     private runTransactionWithAbortSignalFallback;

package/dist/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAQA,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;AAKpB,UAAU,oBAAoB;IAC5B,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAcD;;;;;;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,CAA+C;IAC5E,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;IA2BhC,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;IAkBlH,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":"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"}

package/dist/service.js

@@ -5,11 +5,12 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 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 { createRequestAbortContext, raceWithAbort, trackActiveRequestTransaction, untrackActiveRequestTransaction } from '@fluojs/runtime';
+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;
 /**
  * Prisma runtime facade that owns lifecycle hooks and transaction context access.
@@ -44,7 +45,7 @@ class PrismaService {
    * @returns The request/transaction-scoped client when a transaction is active; otherwise the root client.
    */
   current() {
-    return this.transactions.getStore() ?? this.client;
+    return this.transactions.getStore()?.client ?? this.client;
   }
   async runWithTransactionClient(fn, run, options) {
     if (this.transactions.getStore()) {
@@ -59,7 +60,17 @@ class PrismaService {
       }
       return fn();
     }
-    return run(transactionClient => this.transactions.run(transactionClient, fn), options);
+    const deferredRequestTransactionHandles = new Set();
+    try {
+      return await run(transactionClient => this.transactions.run({
+        client: transactionClient,
+        deferredRequestTransactionHandles
+      }, fn), options);
+    } finally {
+      for (const handle of deferredRequestTransactionHandles) {
+        this.untrackActiveRequestTransaction(handle);
+      }
+    }
   }
   async onModuleInit() {
     if (typeof this.client.$connect === 'function') {
@@ -138,16 +149,72 @@ class PrismaService {
    * error type/message depends on the runtime abort implementation.
    */
   async requestTransaction(fn, signal, options) {
+    const current = this.transactions.getStore();
+    if (current) {
+      if (options !== undefined) {
+        throw new Error(NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR);
+      }
+      return this.runNestedRequestTransaction(current, fn, signal);
+    }
+    this.assertRequestTransactionsAvailable();
     const abortContext = createRequestAbortContext(signal);
     const active = this.trackActiveRequestTransaction(abortContext.controller);
-    const transactionPromise = this.runWithTransactionClient(() => raceWithAbort(fn, abortContext.signal), (callback, transactionOptions) => this.runRequestTransactionWithAbortSignal(callback, abortContext.signal, transactionOptions), options);
     try {
-      return await transactionPromise;
+      const result = await this.runWithRequestTransactionClient(() => raceWithAbort(fn, abortContext.signal), (callback, transactionOptions) => this.runRequestTransactionWithAbortSignal(callback, abortContext.signal, transactionOptions), options, abortContext.signal);
+      this.throwIfRequestAborted(abortContext.signal);
+      return result;
     } finally {
       abortContext.cleanup();
       this.untrackActiveRequestTransaction(active);
     }
   }
+  async runWithRequestTransactionClient(fn, run, options, signal) {
+    if (typeof this.client.$transaction !== 'function') {
+      if (this.serviceOptions.strictTransactions) {
+        throw new Error('Transaction not supported: Prisma client does not implement $transaction.');
+      }
+      return fn();
+    }
+    return run(transactionClient => this.transactions.run({
+      client: transactionClient,
+      requestAbortSignal: signal
+    }, fn), options);
+  }
+  async runNestedRequestTransaction(current, fn, signal) {
+    if (current.requestAbortSignal) {
+      if (signal) {
+        return raceWithAbort(fn, signal);
+      }
+      return fn();
+    }
+    this.assertRequestTransactionsAvailable();
+    const abortContext = createRequestAbortContext(signal);
+    const active = this.trackActiveRequestTransaction(abortContext.controller);
+    current.deferredRequestTransactionHandles?.add(active);
+    try {
+      const result = await this.transactions.run({
+        client: current.client,
+        requestAbortSignal: abortContext.signal
+      }, () => raceWithAbort(fn, abortContext.signal));
+      this.throwIfRequestAborted(abortContext.signal);
+      return result;
+    } finally {
+      abortContext.cleanup();
+      if (!current.deferredRequestTransactionHandles) {
+        this.untrackActiveRequestTransaction(active);
+      }
+    }
+  }
+  assertRequestTransactionsAvailable() {
+    if (this.lifecycleState === 'shutting-down' || this.lifecycleState === 'stopped') {
+      throw new Error(REQUEST_TRANSACTION_UNAVAILABLE_ERROR);
+    }
+  }
+  throwIfRequestAborted(signal) {
+    if (signal.aborted) {
+      throw createAbortError(signal.reason);
+    }
+  }
   runRequestTransactionWithAbortSignal(callback, signal, options) {
     if (!this.canAttemptTransactionAbortSignalOption(options)) {
       return this.client.$transaction(callback, options);

package/dist/status.js

@@ -63,8 +63,8 @@ export function createPrismaPlatformStatusSnapshot(input) {
     },
     health: createHealth(input),
     ownership: {
-      externallyManaged: true,
-      ownsResources: false
+      externallyManaged: false,
+      ownsResources: true
     },
     readiness: createReadiness(input)
   };

package/dist/tokens.d.ts

@@ -1,7 +1,7 @@
 import type { Token } from '@fluojs/core';
 /** Dependency-injection token for the raw Prisma client handle. */
 export declare const PRISMA_CLIENT: unique symbol;
-/** Dependency-injection token for normalized Prisma runtime options. */
+/** Dependency-injection token for public Prisma runtime options, such as strict transaction mode. */
 export declare const PRISMA_OPTIONS: unique symbol;
 /**
  * Returns the DI token for the raw Prisma client bound to a registration name.
@@ -11,7 +11,10 @@ export declare const PRISMA_OPTIONS: unique symbol;
  */
 export declare function getPrismaClientToken(name?: string): Token;
 /**
- * Returns the DI token for normalized Prisma module options bound to a registration name.
+ * Returns the DI token for the public Prisma runtime options bound to a registration name.
+ *
+ * This token resolves the `PRISMA_OPTIONS` public surface consumed by `PrismaService`.
+ * Normalized module options remain internal implementation details.
  *
  * @param name Optional registration name. Omit it to target the default unnamed Prisma registration.
  * @returns The token that resolves the matching Prisma runtime options.

package/dist/tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,mEAAmE;AACnE,eAAO,MAAM,aAAa,eAAmC,CAAC;AAC9D,wEAAwE;AACxE,eAAO,MAAM,cAAc,eAAoC,CAAC;AAgBhE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAMzD;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAM1D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAM1D"}
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE1C,mEAAmE;AACnE,eAAO,MAAM,aAAa,eAAmC,CAAC;AAC9D,qGAAqG;AACrG,eAAO,MAAM,cAAc,eAAoC,CAAC;AAgBhE;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAMzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAM1D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAM1D"}

package/dist/tokens.js

@@ -1,6 +1,6 @@
 /** Dependency-injection token for the raw Prisma client handle. */
 export const PRISMA_CLIENT = Symbol.for('fluo.prisma.client');
-/** Dependency-injection token for normalized Prisma runtime options. */
+/** Dependency-injection token for public Prisma runtime options, such as strict transaction mode. */
 export const PRISMA_OPTIONS = Symbol.for('fluo.prisma.options');
 function normalizePrismaRegistrationName(name) {
   if (name === undefined) {
@@ -25,7 +25,10 @@ export function getPrismaClientToken(name) {
 }
 
 /**
- * Returns the DI token for normalized Prisma module options bound to a registration name.
+ * Returns the DI token for the public Prisma runtime options bound to a registration name.
+ *
+ * This token resolves the `PRISMA_OPTIONS` public surface consumed by `PrismaService`.
+ * Normalized module options remain internal implementation details.
  *
  * @param name Optional registration name. Omit it to target the default unnamed Prisma registration.
  * @returns The token that resolves the matching Prisma runtime options.

package/package.json

@@ -9,7 +9,7 @@
     "transaction",
     "als"
   ],
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -36,11 +36,11 @@
     "dist"
   ],
   "dependencies": {
-    "@fluojs/core": "^1.0.0-beta.4",
-    "@fluojs/http": "^1.0.0-beta.10",
-    "@fluojs/validation": "^1.0.0-beta.3",
-    "@fluojs/runtime": "^1.0.0-beta.11",
-    "@fluojs/di": "^1.0.0-beta.6"
+    "@fluojs/core": "^1.0.0-beta.6",
+    "@fluojs/validation": "^1.0.0-beta.4",
+    "@fluojs/http": "^1.0.0-beta.11",
+    "@fluojs/di": "^1.0.0-beta.8",
+    "@fluojs/runtime": "^1.0.0-beta.12"
   },
   "peerDependencies": {
     "@prisma/client": ">=5.0.0"