@fluojs/prisma 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fluo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ko.md

@@ -0,0 +1,159 @@
+# @fluojs/prisma
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo 애플리케이션을 위한 Prisma 라이프사이클 및 ALS 기반 트랜잭션 컨텍스트 모듈입니다. Prisma 클라이언트를 모듈 시스템에 연결하여 자동 연결 관리 및 요청 범위 트랜잭션을 제공합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [공통 패턴](#공통-패턴)
+  - [PrismaService와 current()](#prismaservice와-current)
+  - [수동 트랜잭션](#수동-트랜잭션)
+  - [자동 요청 트랜잭션](#자동-요청-트랜잭션)
+  - [수동 모듈 조합](#수동-모듈-조합)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+pnpm add @fluojs/prisma
+# @prisma/client도 함께 설치되어 있어야 합니다.
+pnpm add @prisma/client
+```
+
+## 사용 시점
+
+- Prisma를 ORM으로 사용하면서 fluo의 의존성 주입 및 라이프사이클 훅과 통합하고 싶을 때.
+- 여러 서비스와 리포지토리 사이에서 `tx` 객체를 일일이 전달하지 않고도 트랜잭션 컨텍스트를 안정적으로 공유하고 싶을 때.
+- 애플리케이션 시작 시 자동 `$connect`, 종료 시 자동 `$disconnect`가 필요할 때.
+
+## 빠른 시작
+
+루트 모듈에 `PrismaClient` 인스턴스를 전달하여 `PrismaModule`을 등록합니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { PrismaModule } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+@Module({
+  imports: [
+    PrismaModule.forRoot({ client: prisma }),
+  ],
+})
+class AppModule {}
+```
+
+## 공통 패턴
+
+### PrismaService와 current()
+
+`PrismaService`는 Prisma와 상호작용하는 기본 방법입니다. `current()` 메서드는 트랜잭션 범위 내에 있으면 자동으로 트랜잭션용 클라이언트를, 그렇지 않으면 루트 클라이언트를 반환합니다.
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { PrismaService } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
+
+@Inject(PrismaService)
+export class UserRepository {
+  constructor(private readonly prisma: PrismaService<PrismaClient>) {}
+
+  async findById(id: string) {
+    // current()는 생성된 Prisma 타입과 자동완성을 그대로 유지합니다.
+    return this.prisma.current().user.findUnique({ where: { id } });
+  }
+}
+```
+
+### 수동 트랜잭션
+
+`prisma.transaction()`을 사용하여 대화형 트랜잭션 블록을 생성합니다. 블록 내부의 모든 `current()` 호출은 트랜잭션 범위의 클라이언트를 사용합니다.
+
+```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 } });
+});
+```
+
+### 자동 요청 트랜잭션
+
+컨트롤러나 메서드에 `PrismaTransactionInterceptor`를 적용하면 전체 요청을 자동으로 트랜잭션으로 감쌉니다.
+
+```typescript
+import { Post, UseInterceptors } from '@fluojs/http';
+import { PrismaTransactionInterceptor } from '@fluojs/prisma';
+
+@UseInterceptors(PrismaTransactionInterceptor)
+class UserController {
+  @Post()
+  async create() {
+    // 이후 PrismaService.current()를 사용하는 모든 리포지토리 호출은 이 트랜잭션을 공유합니다.
+  }
+}
+```
+
+### 수동 모듈 조합
+
+`PrismaModule.forRoot(...)` / `forRootAsync(...)`를 사용해 Prisma를 등록합니다. 커스텀 `defineModule(...)` 등록 안에서 Prisma 지원을 조합해야 할 때도 동일한 모듈 entrypoint를 import해서 사용하세요.
+
+```typescript
+import { defineModule } from '@fluojs/runtime';
+import { PrismaModule, PrismaService, PrismaTransactionInterceptor } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+class ManualPrismaModule {}
+
+defineModule(ManualPrismaModule, {
+  exports: [PrismaService, PrismaTransactionInterceptor],
+  imports: [PrismaModule.forRoot({ client: prisma })],
+});
+```
+
+## 공개 API 개요
+
+### `PrismaModule`
+
+- `PrismaModule.forRoot(options)` / `PrismaModule.forRootAsync(options)`
+- `forRootAsync(...)`는 `AsyncModuleOptions<PrismaModuleOptions<...>>`를 받습니다.
+- `strictTransactions: true` 설정 시 트랜잭션 미지원 환경에서 즉시 예외를 발생시킵니다.
+
+### `PrismaService<TClient>`
+
+- `current(): TClient | PrismaTransactionClient<TClient>`
+  - 현재 컨텍스트에 맞는 트랜잭션 클라이언트 또는 루트 클라이언트를 반환합니다.
+- `transaction(fn, options?): Promise<T>`
+  - 대화형 트랜잭션 내에서 함수를 실행합니다.
+- `requestTransaction(fn, signal?, options?): Promise<T>`
+  - HTTP 요청 라이프사이클에 특화된 트랜잭션 경계를 실행합니다.
+
+### `PRISMA_CLIENT` (Token)
+
+원시 `PrismaClient` 인스턴스를 위한 주입 토큰입니다.
+
+### 관련 export 타입
+
+- `PrismaModuleOptions`
+- `PrismaTransactionClient<TClient>`
+- `InferPrismaTransactionClient<TClient>`
+- `InferPrismaTransactionOptions<TClient>`
+
+## 관련 패키지
+
+- `@fluojs/runtime`: 애플리케이션 라이프사이클 훅을 관리합니다.
+- `@fluojs/http`: 인터셉터 시스템을 제공합니다.
+- `@fluojs/terminus`: Prisma를 위한 헬스 인디케이터를 제공합니다.
+
+## 예제 소스
+
+- `packages/prisma/src/vertical-slice.test.ts`: 표준 DTO → 서비스 → 리포지토리 → Prisma 흐름 예제.

package/README.md

@@ -0,0 +1,159 @@
+# @fluojs/prisma
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Prisma lifecycle and ALS-backed transaction context for fluo applications. Connects a `PrismaClient` to the module system with automatic connection management and request-scoped transactions.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+  - [PrismaService and current()](#prismaservice-and-current)
+  - [Manual Transactions](#manual-transactions)
+  - [Automatic Request Transactions](#automatic-request-transactions)
+  - [Manual Module Composition](#manual-module-composition)
+- [Public API Overview](#public-api-overview)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+pnpm add @fluojs/prisma
+# Ensure @prisma/client is also installed
+pnpm add @prisma/client
+```
+
+## When to Use
+
+- When using Prisma as your ORM and you want it integrated with fluo's dependency injection and lifecycle hooks.
+- When you need a reliable way to share a transaction context across multiple services and repositories without passing a `tx` object everywhere.
+- When you want automatic `$connect` on startup and `$disconnect` on shutdown.
+
+## Quick Start
+
+Register the `PrismaModule` in your root module by providing a `PrismaClient` instance.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { PrismaModule } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+@Module({
+  imports: [
+    PrismaModule.forRoot({ client: prisma }),
+  ],
+})
+class AppModule {}
+```
+
+## Common Patterns
+
+### PrismaService and current()
+
+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.
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { PrismaService } from '@fluojs/prisma';
+import { PrismaClient } from '@prisma/client';
+
+@Inject(PrismaService)
+export class UserRepository {
+  constructor(private readonly prisma: PrismaService<PrismaClient>) {}
+
+  async findById(id: string) {
+    // current() preserves your generated Prisma types and autocomplete
+    return this.prisma.current().user.findUnique({ where: { id } });
+  }
+}
+```
+
+### Manual Transactions
+
+Use `prisma.transaction()` to create an interactive transaction block. Any calls to `current()` inside the block will use the transaction-scoped client.
+
+```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 } });
+});
+```
+
+### Automatic Request Transactions
+
+Apply the `PrismaTransactionInterceptor` to a controller or method to wrap the entire request in a transaction automatically.
+
+```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
+  }
+}
+```
+
+### 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 { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+class ManualPrismaModule {}
+
+defineModule(ManualPrismaModule, {
+  exports: [PrismaService, PrismaTransactionInterceptor],
+  imports: [PrismaModule.forRoot({ client: prisma })],
+});
+```
+
+## Public API Overview
+
+### `PrismaModule`
+
+- `PrismaModule.forRoot(options)` / `PrismaModule.forRootAsync(options)`
+- `forRootAsync(...)` accepts `AsyncModuleOptions<PrismaModuleOptions<...>>`.
+- Supports `strictTransactions: true` to throw if transaction support is missing.
+
+### `PrismaService<TClient>`
+
+- `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.
+- `requestTransaction(fn, signal?, options?): Promise<T>`
+  - Specialized transaction boundary for HTTP request lifecycles.
+
+### `PRISMA_CLIENT` (Token)
+
+Injectable token for the raw `PrismaClient` instance.
+
+### Related exported types
+
+- `PrismaModuleOptions`
+- `PrismaTransactionClient<TClient>`
+- `InferPrismaTransactionClient<TClient>`
+- `InferPrismaTransactionOptions<TClient>`
+
+## Related Packages
+
+- `@fluojs/runtime`: Manages the application lifecycle hooks.
+- `@fluojs/http`: Provides the interceptor system.
+- `@fluojs/terminus`: Provides a health indicator for Prisma.
+
+## Example Sources
+
+- `packages/prisma/src/vertical-slice.test.ts`: DTO → Service → Repository → Prisma flow.

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './module.js';
+export * from './service.js';
+export * from './status.js';
+export * from './tokens.js';
+export * from './transaction.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './module.js';
+export * from './service.js';
+export * from './status.js';
+export * from './tokens.js';
+export * from './transaction.js';
+export * from './types.js';

package/dist/module.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncModuleOptions } from '@fluojs/core';
+import { type ModuleType } from '@fluojs/runtime';
+import type { InferPrismaTransactionClient, InferPrismaTransactionOptions, PrismaClientLike, PrismaModuleOptions } from './types.js';
+/**
+ * Runtime module entrypoint for Prisma lifecycle and transaction wiring.
+ */
+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`.
+     */
+    static forRoot<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>>(options: PrismaModuleOptions<TClient, TTransactionClient, TTransactionOptions>): ModuleType;
+    /**
+     * Registers Prisma providers from an async DI factory.
+     *
+     * @param options Async module options that resolve Prisma client/module configuration.
+     * @returns A module definition that memoizes async options resolution per module instance.
+     */
+    static forRootAsync<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>>(options: AsyncModuleOptions<PrismaModuleOptions<TClient, TTransactionClient, TTransactionOptions>>): ModuleType;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAgB,MAAM,cAAc,CAAC;AAErE,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAKhE,OAAO,KAAK,EACV,4BAA4B,EAC5B,6BAA6B,EAC7B,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AA6GpB;;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,kBAAkB,CAAC,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,CAAC,CAAC,GACjG,UAAU;CAGd"}

package/dist/module.js

@@ -0,0 +1,81 @@
+import { defineModule } from '@fluojs/runtime';
+import { PrismaService } from './service.js';
+import { PRISMA_CLIENT, PRISMA_OPTIONS } from './tokens.js';
+import { PrismaTransactionInterceptor } from './transaction.js';
+const PRISMA_NORMALIZED_OPTIONS = Symbol('fluo.prisma.normalized-options');
+const PRISMA_MODULE_EXPORTS = [PrismaService, PrismaTransactionInterceptor];
+function normalizePrismaModuleOptions(options) {
+  return {
+    client: options.client,
+    strictTransactions: options.strictTransactions ?? false
+  };
+}
+function createPrismaRuntimeProviders(normalizedOptionsProvider) {
+  return [normalizedOptionsProvider, {
+    inject: [PRISMA_NORMALIZED_OPTIONS],
+    provide: PRISMA_CLIENT,
+    useFactory: options => options.client
+  }, {
+    inject: [PRISMA_NORMALIZED_OPTIONS],
+    provide: PRISMA_OPTIONS,
+    useFactory: options => ({
+      strictTransactions: options.strictTransactions
+    })
+  }, PrismaService, PrismaTransactionInterceptor];
+}
+function buildPrismaModule(options) {
+  class PrismaRootModuleDefinition {}
+  return defineModule(PrismaRootModuleDefinition, {
+    exports: PRISMA_MODULE_EXPORTS,
+    providers: createPrismaRuntimeProviders({
+      provide: PRISMA_NORMALIZED_OPTIONS,
+      useValue: normalizePrismaModuleOptions(options)
+    })
+  });
+}
+function buildPrismaModuleAsync(options) {
+  class PrismaAsyncModuleDefinition {}
+  const factory = options.useFactory;
+  let cachedResult;
+  const memoizedFactory = (...deps) => {
+    if (!cachedResult) {
+      cachedResult = Promise.resolve(factory(...deps)).then(resolved => normalizePrismaModuleOptions(resolved));
+    }
+    return cachedResult;
+  };
+  const normalizedOptionsProvider = {
+    inject: options.inject,
+    provide: PRISMA_NORMALIZED_OPTIONS,
+    scope: 'singleton',
+    useFactory: (...deps) => memoizedFactory(...deps)
+  };
+  return defineModule(PrismaAsyncModuleDefinition, {
+    exports: PRISMA_MODULE_EXPORTS,
+    providers: createPrismaRuntimeProviders(normalizedOptionsProvider)
+  });
+}
+
+/**
+ * Runtime module entrypoint for Prisma lifecycle and transaction wiring.
+ */
+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`.
+   */
+  static forRoot(options) {
+    return buildPrismaModule(options);
+  }
+
+  /**
+   * Registers Prisma providers from an async DI factory.
+   *
+   * @param options Async module options that resolve Prisma client/module configuration.
+   * @returns A module definition that memoizes async options resolution per module instance.
+   */
+  static forRootAsync(options) {
+    return buildPrismaModuleAsync(options);
+  }
+}

package/dist/service.d.ts

@@ -0,0 +1,90 @@
+import type { OnApplicationShutdown, OnModuleInit } from '@fluojs/runtime';
+import type { InferPrismaTransactionClient, InferPrismaTransactionOptions, PrismaClientLike, PrismaHandleProvider } from './types.js';
+interface PrismaServiceOptions {
+    strictTransactions: boolean;
+}
+/**
+ * Prisma runtime facade that owns lifecycle hooks and transaction context access.
+ *
+ * @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 declare class PrismaService<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>> implements PrismaHandleProvider<TClient, TTransactionClient, TTransactionOptions>, OnModuleInit, OnApplicationShutdown {
+    private readonly client;
+    private readonly serviceOptions;
+    private readonly transactions;
+    private readonly activeRequestTransactions;
+    private transactionAbortSignalSupport;
+    private lifecycleState;
+    constructor(client: TClient, serviceOptions?: PrismaServiceOptions);
+    /**
+     * Returns the active Prisma handle for the current async context.
+     *
+     * @example
+     * ```ts
+     * const user = await prisma.current().user.findUnique({ where: { id } });
+     * ```
+     *
+     * @returns The request/transaction-scoped client when a transaction is active; otherwise the root client.
+     */
+    current(): TClient | TTransactionClient;
+    private runWithTransactionClient;
+    onModuleInit(): Promise<void>;
+    onApplicationShutdown(): Promise<void>;
+    /**
+     * Creates a shared platform-status snapshot for runtime/CLI/Studio health surfaces.
+     *
+     * @returns Platform snapshot data reflecting lifecycle state and transaction capability diagnostics.
+     */
+    createPlatformStatusSnapshot(): import("@fluojs/runtime").PersistencePlatformStatusSnapshot;
+    /**
+     * Opens a Prisma interactive transaction boundary and executes the callback in that context.
+     *
+     * @example
+     * ```ts
+     * await prisma.transaction(async () => {
+     *   await prisma.current().user.create({ data });
+     * });
+     * ```
+     *
+     * @param fn Callback executed inside the transaction flow where `current()` resolves from ALS to the active transaction client,
+     * or reuses the already-active context / direct-execution path when no new boundary is opened.
+     * @param options Optional Prisma transaction options forwarded to `$transaction`.
+     * @returns The callback result, after commit when a new interactive transaction is opened, or from direct execution when
+     * nested context reuse or non-strict `$transaction` fallback applies.
+     * @throws {Error} When nested transaction options are provided while already inside an active transaction.
+     * @throws {Error} When strict transaction mode is enabled and the Prisma client does not implement `$transaction`.
+     */
+    transaction<T>(fn: () => Promise<T>, options?: TTransactionOptions): Promise<T>;
+    /**
+     * Opens an abort-aware request transaction boundary.
+     *
+     * @example
+     * ```ts
+     * await prisma.requestTransaction(async () => next.handle(), request.signal);
+     * ```
+     *
+     * @param fn Callback executed inside the request-scoped transaction flow where `current()` resolves from ALS to the active
+     * transaction client, or reuses the already-active context / direct-execution path when no new boundary is opened.
+     * @param signal Optional abort signal propagated to request transaction handling.
+     * @param options Optional Prisma transaction options forwarded to `$transaction`.
+     * @returns The callback result, after commit when a new interactive transaction is opened, or from direct execution when
+     * nested context reuse or non-strict `$transaction` fallback applies.
+     * @throws {Error} When nested transaction options are provided while already inside an active transaction.
+     * @throws {Error} When strict transaction mode is enabled and the Prisma client does not implement `$transaction`.
+     * @throws {Error} Propagates an abort-related error when `signal` aborts before the transaction callback settles; concrete
+     * error type/message depends on the runtime abort implementation.
+     */
+    requestTransaction<T>(fn: () => Promise<T>, signal?: AbortSignal, options?: TTransactionOptions): Promise<T>;
+    private runRequestTransactionWithAbortSignal;
+    private canAttemptTransactionAbortSignalOption;
+    private runTransactionWithAbortSignalFallback;
+    private shouldRetryWithoutAbortSignal;
+    private toErrorMessage;
+    private withTransactionAbortSignal;
+    private trackActiveRequestTransaction;
+    private untrackActiveRequestTransaction;
+}
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +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"}

package/dist/service.js

@@ -0,0 +1,218 @@
+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 { AsyncLocalStorage } from 'node:async_hooks';
+import { 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.';
+let _PrismaService;
+/**
+ * Prisma runtime facade that owns lifecycle hooks and transaction context access.
+ *
+ * @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.
+ */
+class PrismaService {
+  static {
+    [_PrismaService, _initClass] = _applyDecs(this, [Inject(PRISMA_CLIENT, PRISMA_OPTIONS)], []).c;
+  }
+  transactions = new AsyncLocalStorage();
+  activeRequestTransactions = new Set();
+  transactionAbortSignalSupport = 'unknown';
+  lifecycleState = 'created';
+  constructor(client, serviceOptions = {
+    strictTransactions: false
+  }) {
+    this.client = client;
+    this.serviceOptions = serviceOptions;
+  }
+
+  /**
+   * Returns the active Prisma handle for the current async context.
+   *
+   * @example
+   * ```ts
+   * const user = await prisma.current().user.findUnique({ where: { id } });
+   * ```
+   *
+   * @returns The request/transaction-scoped client when a transaction is active; otherwise the root client.
+   */
+  current() {
+    return this.transactions.getStore() ?? this.client;
+  }
+  async runWithTransactionClient(fn, run, options) {
+    if (this.transactions.getStore()) {
+      if (options !== undefined) {
+        throw new Error(NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR);
+      }
+      return fn();
+    }
+    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(transactionClient, fn), options);
+  }
+  async onModuleInit() {
+    if (typeof this.client.$connect === 'function') {
+      await this.client.$connect();
+    }
+    this.lifecycleState = 'ready';
+  }
+  async onApplicationShutdown() {
+    this.lifecycleState = 'shutting-down';
+    for (const transaction of this.activeRequestTransactions) {
+      transaction.abort(new Error('Application shutdown interrupted an open request transaction.'));
+    }
+    await Promise.allSettled(Array.from(this.activeRequestTransactions, transaction => transaction.settled));
+    if (typeof this.client.$disconnect === 'function') {
+      await this.client.$disconnect();
+    }
+    this.lifecycleState = 'stopped';
+  }
+
+  /**
+   * Creates a shared platform-status snapshot for runtime/CLI/Studio health surfaces.
+   *
+   * @returns Platform snapshot data reflecting lifecycle state and transaction capability diagnostics.
+   */
+  createPlatformStatusSnapshot() {
+    return createPrismaPlatformStatusSnapshot({
+      activeRequestTransactions: this.activeRequestTransactions.size,
+      lifecycleState: this.lifecycleState,
+      strictTransactions: this.serviceOptions.strictTransactions,
+      supportsConnect: typeof this.client.$connect === 'function',
+      supportsDisconnect: typeof this.client.$disconnect === 'function',
+      supportsTransaction: typeof this.client.$transaction === 'function',
+      transactionAbortSignalSupport: this.transactionAbortSignalSupport
+    });
+  }
+
+  /**
+   * Opens a Prisma interactive transaction boundary and executes the callback in that context.
+   *
+   * @example
+   * ```ts
+   * await prisma.transaction(async () => {
+   *   await prisma.current().user.create({ data });
+   * });
+   * ```
+   *
+   * @param fn Callback executed inside the transaction flow where `current()` resolves from ALS to the active transaction client,
+   * or reuses the already-active context / direct-execution path when no new boundary is opened.
+   * @param options Optional Prisma transaction options forwarded to `$transaction`.
+   * @returns The callback result, after commit when a new interactive transaction is opened, or from direct execution when
+   * nested context reuse or non-strict `$transaction` fallback applies.
+   * @throws {Error} When nested transaction options are provided while already inside an active transaction.
+   * @throws {Error} When strict transaction mode is enabled and the Prisma client does not implement `$transaction`.
+   */
+  async transaction(fn, options) {
+    return this.runWithTransactionClient(fn, (callback, transactionOptions) => this.client.$transaction(callback, transactionOptions), options);
+  }
+
+  /**
+   * Opens an abort-aware request transaction boundary.
+   *
+   * @example
+   * ```ts
+   * await prisma.requestTransaction(async () => next.handle(), request.signal);
+   * ```
+   *
+   * @param fn Callback executed inside the request-scoped transaction flow where `current()` resolves from ALS to the active
+   * transaction client, or reuses the already-active context / direct-execution path when no new boundary is opened.
+   * @param signal Optional abort signal propagated to request transaction handling.
+   * @param options Optional Prisma transaction options forwarded to `$transaction`.
+   * @returns The callback result, after commit when a new interactive transaction is opened, or from direct execution when
+   * nested context reuse or non-strict `$transaction` fallback applies.
+   * @throws {Error} When nested transaction options are provided while already inside an active transaction.
+   * @throws {Error} When strict transaction mode is enabled and the Prisma client does not implement `$transaction`.
+   * @throws {Error} Propagates an abort-related error when `signal` aborts before the transaction callback settles; concrete
+   * error type/message depends on the runtime abort implementation.
+   */
+  async requestTransaction(fn, signal, options) {
+    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;
+    } finally {
+      abortContext.cleanup();
+      this.untrackActiveRequestTransaction(active);
+    }
+  }
+  runRequestTransactionWithAbortSignal(callback, signal, options) {
+    if (!this.canAttemptTransactionAbortSignalOption(options)) {
+      return this.client.$transaction(callback, options);
+    }
+    return this.runTransactionWithAbortSignalFallback(callback, signal, options);
+  }
+  canAttemptTransactionAbortSignalOption(options) {
+    if (options !== undefined && (typeof options !== 'object' || options === null)) {
+      return false;
+    }
+    if (this.transactionAbortSignalSupport === 'unsupported') {
+      return false;
+    }
+    return true;
+  }
+  async runTransactionWithAbortSignalFallback(callback, signal, options) {
+    let callbackInvoked = false;
+    const wrappedCallback = transactionClient => {
+      callbackInvoked = true;
+      return callback(transactionClient);
+    };
+    try {
+      const result = await this.client.$transaction(wrappedCallback, this.withTransactionAbortSignal(options, signal));
+      this.transactionAbortSignalSupport = 'supported';
+      return result;
+    } catch (error) {
+      if (callbackInvoked || !this.shouldRetryWithoutAbortSignal(error)) {
+        throw error;
+      }
+      this.transactionAbortSignalSupport = 'unsupported';
+      return this.client.$transaction(callback, options);
+    }
+  }
+  shouldRetryWithoutAbortSignal(error) {
+    if (this.transactionAbortSignalSupport === 'supported') {
+      return false;
+    }
+    const message = this.toErrorMessage(error);
+    return /signal/i.test(message) && /(argument|field|option|unknown|invalid|unexpected|unsupported|not support)/i.test(message);
+  }
+  toErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+  withTransactionAbortSignal(options, signal) {
+    if (options === undefined) {
+      return {
+        signal
+      };
+    }
+    return {
+      ...options,
+      signal
+    };
+  }
+  trackActiveRequestTransaction(controller) {
+    return trackActiveRequestTransaction(this.activeRequestTransactions, controller);
+  }
+  untrackActiveRequestTransaction(handle) {
+    untrackActiveRequestTransaction(this.activeRequestTransactions, handle);
+  }
+  static {
+    _initClass();
+  }
+}
+export { _PrismaService as PrismaService };

package/dist/status.d.ts

@@ -0,0 +1,14 @@
+import type { PersistencePlatformStatusSnapshot } from '@fluojs/runtime';
+type PrismaPlatformLifecycleState = 'created' | 'ready' | 'shutting-down' | 'stopped';
+type PrismaPlatformStatusSnapshotInput = {
+    activeRequestTransactions: number;
+    lifecycleState: PrismaPlatformLifecycleState;
+    strictTransactions: boolean;
+    supportsConnect: boolean;
+    supportsDisconnect: boolean;
+    supportsTransaction: boolean;
+    transactionAbortSignalSupport: 'unknown' | 'supported' | 'unsupported';
+};
+export declare function createPrismaPlatformStatusSnapshot(input: PrismaPlatformStatusSnapshotInput): PersistencePlatformStatusSnapshot;
+export {};
+//# sourceMappingURL=status.d.ts.map

package/dist/status.d.ts.map

@@ -0,0 +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;AAqDF,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,iCAAiC,GACvC,iCAAiC,CAmBnC"}

package/dist/status.js

@@ -0,0 +1,64 @@
+function createReadiness(input) {
+  if (input.lifecycleState === 'shutting-down') {
+    return {
+      critical: true,
+      reason: 'Prisma integration is shutting down.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'stopped') {
+    return {
+      critical: true,
+      reason: 'Prisma integration is stopped.',
+      status: 'not-ready'
+    };
+  }
+  if (input.strictTransactions && !input.supportsTransaction) {
+    return {
+      critical: true,
+      reason: 'Prisma strictTransactions is enabled but client.$transaction is unavailable.',
+      status: 'not-ready'
+    };
+  }
+  return {
+    critical: true,
+    status: 'ready'
+  };
+}
+function createHealth(input) {
+  if (input.lifecycleState === 'stopped') {
+    return {
+      reason: 'Prisma integration has been disconnected.',
+      status: 'unhealthy'
+    };
+  }
+  if (input.lifecycleState === 'shutting-down') {
+    return {
+      reason: 'Prisma integration is draining request transactions during shutdown.',
+      status: 'degraded'
+    };
+  }
+  return {
+    status: 'healthy'
+  };
+}
+export function createPrismaPlatformStatusSnapshot(input) {
+  return {
+    details: {
+      activeRequestTransactions: input.activeRequestTransactions,
+      lifecycleState: input.lifecycleState,
+      strictTransactions: input.strictTransactions,
+      supportsConnect: input.supportsConnect,
+      supportsDisconnect: input.supportsDisconnect,
+      supportsTransaction: input.supportsTransaction,
+      transactionAbortSignalSupport: input.transactionAbortSignalSupport,
+      transactionContext: 'als'
+    },
+    health: createHealth(input),
+    ownership: {
+      externallyManaged: true,
+      ownsResources: false
+    },
+    readiness: createReadiness(input)
+  };
+}

package/dist/tokens.d.ts

@@ -0,0 +1,5 @@
+/** Dependency-injection token for the raw Prisma client handle. */
+export declare const PRISMA_CLIENT: unique symbol;
+/** Dependency-injection token for normalized Prisma runtime options. */
+export declare const PRISMA_OPTIONS: unique symbol;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,eAAO,MAAM,aAAa,eAAmC,CAAC;AAC9D,wEAAwE;AACxE,eAAO,MAAM,cAAc,eAAoC,CAAC"}

package/dist/tokens.js

@@ -0,0 +1,4 @@
+/** 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. */
+export const PRISMA_OPTIONS = Symbol.for('fluo.prisma.options');

package/dist/transaction.d.ts

@@ -0,0 +1,25 @@
+import type { Interceptor, InterceptorContext } from '@fluojs/http';
+import { PrismaService } from './service.js';
+import type { PrismaClientLike } from './types.js';
+/**
+ * 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.
+ */
+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>;
+}
+//# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -0,0 +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"}

package/dist/transaction.js

@@ -0,0 +1,39 @@
+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;
+  }
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+
+  /**
+   * 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);
+  }
+  static {
+    _initClass();
+  }
+}
+export { _PrismaTransactionInt as PrismaTransactionInterceptor };

package/dist/types.d.ts

@@ -0,0 +1,83 @@
+import type { MaybePromise } from '@fluojs/core';
+type PrismaTransactionCallback<TTransactionClient, TResult> = (client: TTransactionClient) => Promise<TResult>;
+/**
+ * Infers the transaction-scoped Prisma client type exposed inside `$transaction(...)` callbacks.
+ *
+ * @typeParam TClient Root Prisma client shape registered with Fluo.
+ */
+export type InferPrismaTransactionClient<TClient> = TClient extends {
+    $transaction?: <T>(callback: PrismaTransactionCallback<infer TTransactionClient, T>, options?: infer _TTransactionOptions) => Promise<T>;
+} ? TTransactionClient : TClient;
+/**
+ * Infers the optional Prisma transaction options object accepted by the registered client.
+ *
+ * @typeParam TClient Root Prisma client shape registered with Fluo.
+ */
+export type InferPrismaTransactionOptions<TClient> = TClient extends {
+    $transaction?: <T>(callback: PrismaTransactionCallback<infer _TTransactionClient, T>, options?: infer TTransactionOptions) => Promise<T>;
+} ? TTransactionOptions : unknown;
+/**
+ * Alias for the transaction-scoped Prisma client type derived from a root client.
+ *
+ * @typeParam TClient Root Prisma client shape registered with Fluo.
+ */
+export type PrismaTransactionClient<TClient> = InferPrismaTransactionClient<TClient>;
+/**
+ * Minimal Prisma client seam required by the Fluo runtime wrapper.
+ *
+ * @typeParam TTransactionClient Client shape passed into interactive transaction callbacks.
+ * @typeParam TTransactionOptions Options shape forwarded to `$transaction(...)`.
+ */
+export interface PrismaClientLike<TTransactionClient = unknown, TTransactionOptions = unknown> {
+    $connect?(): MaybePromise<void>;
+    $disconnect?(): MaybePromise<void>;
+    $transaction?<T>(callback: PrismaTransactionCallback<TTransactionClient, T>, options?: TTransactionOptions): Promise<T>;
+}
+/**
+ * Configures how `PrismaModule` wires a Prisma client into the Fluo lifecycle.
+ *
+ * @typeParam TClient Root Prisma client shape registered in the module.
+ * @typeParam TTransactionClient Transaction-scoped client resolved by `current()` inside transaction boundaries.
+ * @typeParam TTransactionOptions Options forwarded to Prisma interactive transactions.
+ */
+export interface PrismaModuleOptions<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>> {
+    /** Root Prisma client shared outside ambient transaction scopes. */
+    client: TClient;
+    /**
+     * Throws when transaction helpers are used against a client that does not implement `$transaction(...)`.
+     *
+     * @remarks
+     * Leave this disabled when you want `transaction()` / `requestTransaction()` to fall back to direct execution.
+     */
+    strictTransactions?: boolean;
+}
+/**
+ * Public transaction-aware Prisma contract exposed through dependency injection.
+ *
+ * @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 interface PrismaHandleProvider<TClient extends PrismaClientLike<TTransactionClient, TTransactionOptions>, TTransactionClient = InferPrismaTransactionClient<TClient>, TTransactionOptions = InferPrismaTransactionOptions<TClient>> {
+    /** Returns the ambient transaction client when present, or the root Prisma client otherwise. */
+    current(): TClient | TTransactionClient;
+    /**
+     * Opens an abort-aware request transaction boundary around `fn`.
+     *
+     * @param fn Callback executed within the request transaction scope.
+     * @param signal Optional abort signal linked to the request lifecycle.
+     * @param options Optional Prisma transaction options forwarded to `$transaction(...)`.
+     * @returns The callback result after the request transaction finishes or the direct-execution fallback completes.
+     */
+    requestTransaction<T>(fn: () => Promise<T>, signal?: AbortSignal, options?: TTransactionOptions): Promise<T>;
+    /**
+     * Opens an interactive transaction boundary around `fn`.
+     *
+     * @param fn Callback executed within the transaction scope.
+     * @param options Optional Prisma transaction options forwarded to `$transaction(...)`.
+     * @returns The callback result after the transaction finishes or the direct-execution fallback completes.
+     */
+    transaction<T>(fn: () => Promise<T>, options?: TTransactionOptions): Promise<T>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,KAAK,yBAAyB,CAAC,kBAAkB,EAAE,OAAO,IAAI,CAAC,MAAM,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/G;;;;GAIG;AACH,MAAM,MAAM,4BAA4B,CAAC,OAAO,IAAI,OAAO,SAAS;IAClE,YAAY,CAAC,EAAE,CAAC,CAAC,EACf,QAAQ,EAAE,yBAAyB,CAAC,MAAM,kBAAkB,EAAE,CAAC,CAAC,EAChE,OAAO,CAAC,EAAE,MAAM,oBAAoB,KACjC,OAAO,CAAC,CAAC,CAAC,CAAC;CACjB,GACG,kBAAkB,GAClB,OAAO,CAAC;AAEZ;;;;GAIG;AACH,MAAM,MAAM,6BAA6B,CAAC,OAAO,IAAI,OAAO,SAAS;IACnE,YAAY,CAAC,EAAE,CAAC,CAAC,EACf,QAAQ,EAAE,yBAAyB,CAAC,MAAM,mBAAmB,EAAE,CAAC,CAAC,EACjE,OAAO,CAAC,EAAE,MAAM,mBAAmB,KAChC,OAAO,CAAC,CAAC,CAAC,CAAC;CACjB,GACG,mBAAmB,GACnB,OAAO,CAAC;AAEZ;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,CAAC,OAAO,IAAI,4BAA4B,CAAC,OAAO,CAAC,CAAC;AAErF;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB,CAAC,kBAAkB,GAAG,OAAO,EAAE,mBAAmB,GAAG,OAAO;IAC3F,QAAQ,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAChC,WAAW,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACnC,YAAY,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,yBAAyB,CAAC,kBAAkB,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACzH;AAED;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB,CAClC,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC;IAE5D,oEAAoE;IACpE,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB,CACnC,OAAO,SAAS,gBAAgB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,EACzE,kBAAkB,GAAG,4BAA4B,CAAC,OAAO,CAAC,EAC1D,mBAAmB,GAAG,6BAA6B,CAAC,OAAO,CAAC;IAE5D,gGAAgG;IAChG,OAAO,IAAI,OAAO,GAAG,kBAAkB,CAAC;IACxC;;;;;;;OAOG;IACH,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,CAAC;IAC7G;;;;;;OAMG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACjF"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@fluojs/prisma",
+  "description": "Prisma lifecycle and ALS-backed transaction context for Fluo, with async module factory and strict transaction mode.",
+  "keywords": [
+    "fluo",
+    "prisma",
+    "orm",
+    "database",
+    "transaction",
+    "als"
+  ],
+  "version": "1.0.0-beta.1",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fluojs/fluo.git",
+    "directory": "packages/prisma"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@fluojs/core": "^1.0.0-beta.1",
+    "@fluojs/http": "^1.0.0-beta.1",
+    "@fluojs/runtime": "^1.0.0-beta.1",
+    "@fluojs/validation": "^1.0.0-beta.1",
+    "@fluojs/di": "^1.0.0-beta.1"
+  },
+  "peerDependencies": {
+    "@prisma/client": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "prebuild": "node ../../tooling/scripts/clean-dist.mjs",
+    "build": "pnpm exec babel src --extensions .ts --ignore 'src/**/*.test.ts' --out-dir dist --config-file ../../tooling/babel/babel.config.cjs && pnpm exec tsc -p tsconfig.build.json",
+    "typecheck": "pnpm exec tsc -p tsconfig.json --noEmit",
+    "test": "pnpm exec vitest run -c vitest.config.ts",
+    "test:watch": "pnpm exec vitest -c vitest.config.ts"
+  }
+}