@fluojs/drizzle 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,143 @@
+# @fluojs/drizzle
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+트랜잭션 인지형 데이터베이스 래퍼와 선택적 dispose hook을 제공하는 fluo용 Drizzle ORM 통합 패키지입니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [주요 패턴](#주요-패턴)
+- [수동 모듈 구성](#수동-모듈-구성)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/drizzle
+```
+
+## 사용 시점
+
+- Drizzle을 다른 fluo 모듈과 같은 DI·모듈·라이프사이클 모델 안에 넣고 싶을 때
+- repository 코드가 root handle과 현재 트랜잭션 handle 사이를 `current()` 하나로 다루고 싶을 때
+- 애플리케이션 종료 시 underlying driver 정리 로직도 함께 실행해야 할 때
+
+## 빠른 시작
+
+```ts
+import { ConfigService } from '@fluojs/config';
+import { Module } from '@fluojs/core';
+import { DrizzleModule } from '@fluojs/drizzle';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+
+@Module({
+  imports: [
+    DrizzleModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: async (config: ConfigService) => {
+        const pool = new Pool({
+          connectionString: config.getOrThrow<string>('DATABASE_URL'),
+        });
+
+        return {
+          database: drizzle(pool),
+          dispose: async () => {
+            await pool.end();
+          },
+        };
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## 주요 패턴
+
+### repository에서 `DrizzleDatabase.current()` 사용하기
+
+```ts
+import { DrizzleDatabase } from '@fluojs/drizzle';
+import { eq } from 'drizzle-orm';
+import { users } from './schema';
+
+export class UserRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  async findById(id: string) {
+    return this.db.current().select().from(users).where(eq(users.id, id));
+  }
+}
+```
+
+### 수동 트랜잭션 경계
+
+```ts
+await this.db.transaction(async () => {
+  const tx = this.db.current();
+  await tx.insert(users).values(user);
+  await tx.insert(profiles).values(profile);
+});
+```
+
+### 인터셉터 기반 요청 단위 트랜잭션
+
+```ts
+import { UseInterceptors } from '@fluojs/http';
+import { DrizzleTransactionInterceptor } from '@fluojs/drizzle';
+
+@UseInterceptors(DrizzleTransactionInterceptor)
+class UsersController {}
+```
+
+## 수동 모듈 구성
+
+`DrizzleModule.forRoot(...)` / `forRootAsync(...)`를 사용해 Drizzle을 등록합니다. 커스텀 `defineModule(...)` 안에서 Drizzle 지원을 조합해야 할 때도 동일한 모듈 entrypoint를 import해서 사용하세요.
+
+```ts
+import { defineModule } from '@fluojs/runtime';
+import { DrizzleDatabase, DrizzleModule, DrizzleTransactionInterceptor } from '@fluojs/drizzle';
+
+const database = {
+  transaction: async <T>(callback: (tx: typeof database) => Promise<T>) => callback(database),
+};
+
+class ManualDrizzleModule {}
+
+defineModule(ManualDrizzleModule, {
+  exports: [DrizzleDatabase, DrizzleTransactionInterceptor],
+  imports: [DrizzleModule.forRoot({ database })],
+});
+```
+
+## 공개 API 개요
+
+- `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`
+- `DrizzleDatabase`
+- `DrizzleTransactionInterceptor`
+- `DRIZZLE_DATABASE`, `DRIZZLE_DISPOSE`, `DRIZZLE_OPTIONS`
+- `createDrizzlePlatformStatusSnapshot(...)`
+
+### `DrizzleModule`
+
+- `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`
+- `forRootAsync(...)`는 `AsyncModuleOptions<DrizzleModuleOptions<...>>`를 받습니다.
+- `strictTransactions: true`를 설정하면 transaction 지원이 없는 database handle에서 예외를 던집니다.
+
+## 관련 패키지
+
+- `@fluojs/runtime`: 모듈 시작과 종료 순서를 관리합니다.
+- `@fluojs/http`: 요청 단위 트랜잭션에 쓰이는 인터셉터 파이프라인을 제공합니다.
+- `@fluojs/prisma`, `@fluojs/mongoose`: 같은 런타임 모델 위에서 동작하는 다른 데이터 통합 패키지입니다.
+
+## 예제 소스
+
+- `packages/drizzle/src/vertical-slice.test.ts`
+- `packages/drizzle/src/module.test.ts`
+- `packages/drizzle/src/public-api.test.ts`

package/README.md

@@ -0,0 +1,143 @@
+# @fluojs/drizzle
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Drizzle ORM integration for fluo with a transaction-aware database wrapper and an optional dispose hook.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+- [Manual Module Composition](#manual-module-composition)
+- [Public API Overview](#public-api-overview)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+npm install @fluojs/drizzle
+```
+
+## When to Use
+
+- when Drizzle should participate in the same module, DI, and lifecycle model as the rest of the app
+- when repositories need a single `current()` seam that switches between the root handle and the active transaction handle
+- when application shutdown should also run an explicit cleanup hook for the underlying driver resources
+
+## Quick Start
+
+```ts
+import { ConfigService } from '@fluojs/config';
+import { Module } from '@fluojs/core';
+import { DrizzleModule } from '@fluojs/drizzle';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+
+@Module({
+  imports: [
+    DrizzleModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: async (config: ConfigService) => {
+        const pool = new Pool({
+          connectionString: config.getOrThrow<string>('DATABASE_URL'),
+        });
+
+        return {
+          database: drizzle(pool),
+          dispose: async () => {
+            await pool.end();
+          },
+        };
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## Common Patterns
+
+### Use `DrizzleDatabase.current()` inside repositories
+
+```ts
+import { DrizzleDatabase } from '@fluojs/drizzle';
+import { eq } from 'drizzle-orm';
+import { users } from './schema';
+
+export class UserRepository {
+  constructor(private readonly db: DrizzleDatabase) {}
+
+  async findById(id: string) {
+    return this.db.current().select().from(users).where(eq(users.id, id));
+  }
+}
+```
+
+### Manual transaction boundaries
+
+```ts
+await this.db.transaction(async () => {
+  const tx = this.db.current();
+  await tx.insert(users).values(user);
+  await tx.insert(profiles).values(profile);
+});
+```
+
+### Request-scoped transactions with an interceptor
+
+```ts
+import { UseInterceptors } from '@fluojs/http';
+import { DrizzleTransactionInterceptor } from '@fluojs/drizzle';
+
+@UseInterceptors(DrizzleTransactionInterceptor)
+class UsersController {}
+```
+
+## Manual Module Composition
+
+Use `DrizzleModule.forRoot(...)` / `forRootAsync(...)` to register Drizzle. When you need to compose Drizzle support inside a custom `defineModule(...)` registration, import the module entrypoint there as well.
+
+```ts
+import { defineModule } from '@fluojs/runtime';
+import { DrizzleDatabase, DrizzleModule, DrizzleTransactionInterceptor } from '@fluojs/drizzle';
+
+const database = {
+  transaction: async <T>(callback: (tx: typeof database) => Promise<T>) => callback(database),
+};
+
+class ManualDrizzleModule {}
+
+defineModule(ManualDrizzleModule, {
+  exports: [DrizzleDatabase, DrizzleTransactionInterceptor],
+  imports: [DrizzleModule.forRoot({ database })],
+});
+```
+
+## Public API Overview
+
+- `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`
+- `DrizzleDatabase`
+- `DrizzleTransactionInterceptor`
+- `DRIZZLE_DATABASE`, `DRIZZLE_DISPOSE`, `DRIZZLE_OPTIONS`
+- `createDrizzlePlatformStatusSnapshot(...)`
+
+### `DrizzleModule`
+
+- `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`
+- `forRootAsync(...)` accepts `AsyncModuleOptions<DrizzleModuleOptions<...>>`.
+- Supports `strictTransactions: true` to throw if transaction support is missing.
+
+## Related Packages
+
+- `@fluojs/runtime`: owns module startup and shutdown sequencing
+- `@fluojs/http`: provides the interceptor pipeline used for request transactions
+- `@fluojs/prisma` and `@fluojs/mongoose`: alternate ORM/ODM integrations with the same fluo runtime model
+
+## Example Sources
+
+- `packages/drizzle/src/vertical-slice.test.ts`
+- `packages/drizzle/src/module.test.ts`
+- `packages/drizzle/src/public-api.test.ts`

package/dist/database.d.ts

@@ -0,0 +1,73 @@
+import type { OnApplicationShutdown } from '@fluojs/runtime';
+import type { DrizzleDatabaseLike, DrizzleHandleProvider } from './types.js';
+type DrizzleRuntimeOptions = {
+    strictTransactions: boolean;
+};
+/**
+ * Transaction-aware Drizzle wrapper that integrates request scoping and shutdown handling with the Fluo runtime.
+ *
+ * @typeParam TDatabase Root Drizzle database handle registered in the module.
+ * @typeParam TTransactionDatabase Transaction-scoped database handle resolved inside `database.transaction(...)` callbacks.
+ * @typeParam TTransactionOptions Options forwarded to the underlying Drizzle transaction runner.
+ */
+export declare class DrizzleDatabase<TDatabase extends DrizzleDatabaseLike<TTransactionDatabase, TTransactionOptions>, TTransactionDatabase = TDatabase, TTransactionOptions = unknown> implements DrizzleHandleProvider<TDatabase, TTransactionDatabase, TTransactionOptions>, OnApplicationShutdown {
+    private readonly database;
+    private readonly dispose?;
+    private readonly databaseOptions;
+    private readonly transactions;
+    private readonly activeRequestTransactions;
+    private lifecycleState;
+    constructor(database: TDatabase, dispose?: ((database: TDatabase) => Promise<void> | void) | undefined, databaseOptions?: DrizzleRuntimeOptions);
+    /**
+     * Returns the active transaction handle when present, otherwise the root Drizzle database handle.
+     *
+     * @example
+     * ```ts
+     * return db.current().select().from(users);
+     * ```
+     *
+     * @returns The transaction-scoped database inside an active boundary, or the root database outside one.
+     */
+    current(): TDatabase | TTransactionDatabase;
+    /** Aborts active request transactions, waits for settlement, then runs the optional dispose hook. */
+    onApplicationShutdown(): Promise<void>;
+    /** Produces the shared persistence status snapshot for platform diagnostics surfaces. */
+    createPlatformStatusSnapshot(): import("@fluojs/runtime").PersistencePlatformStatusSnapshot;
+    /**
+     * Opens a Drizzle transaction boundary or reuses the current one when already inside a transaction.
+     *
+     * @example
+     * ```ts
+     * await db.transaction(async () => {
+     *   await db.current().insert(users).values(user);
+     * });
+     * ```
+     *
+     * @param fn Callback executed inside the transaction scope.
+     * @param options Optional transaction options forwarded to `database.transaction(...)`.
+     * @returns The callback result after the transaction finishes or the direct-execution fallback completes.
+     */
+    transaction<T>(fn: () => Promise<T>, options?: TTransactionOptions): Promise<T>;
+    /**
+     * Opens an abort-aware request transaction boundary for the current HTTP request.
+     *
+     * @example
+     * ```ts
+     * await db.requestTransaction(async () => next.handle(), request.signal);
+     * ```
+     *
+     * @param fn Callback executed inside the request transaction scope.
+     * @param signal Optional abort signal linked to the request lifecycle.
+     * @param options Optional transaction options forwarded to `database.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>;
+    private executeTransaction;
+    private executeRequestTransaction;
+    private executeRequestFallback;
+    private trackActiveRequestTransaction;
+    private untrackActiveRequestTransaction;
+    private resolveTransactionRunner;
+}
+export {};
+//# sourceMappingURL=database.d.ts.map

package/dist/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAK7D,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAqBpB,KAAK,qBAAqB,GAAG;IAC3B,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;;;;;GAMG;AACH,qBACa,eAAe,CAC1B,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAChF,oBAAoB,GAAG,SAAS,EAChC,mBAAmB,GAAG,OAAO,CAC7B,YAAW,qBAAqB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,qBAAqB;IAO3G,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAPlC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAiD;IAC9E,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,cAAc,CAAkD;gBAGrD,QAAQ,EAAE,SAAS,EACnB,OAAO,CAAC,GAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,aAAA,EACvD,eAAe,GAAE,qBAAqD;IAGzF;;;;;;;;;OASG;IACH,OAAO,IAAI,SAAS,GAAG,oBAAoB;IAI3C,qGAAqG;IAC/F,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5C,yFAAyF;IACzF,4BAA4B;IAS5B;;;;;;;;;;;;;OAaG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,CAAC,CAAC;IAIrF;;;;;;;;;;;;OAYG;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;YAIpG,kBAAkB;YAoClB,yBAAyB;YAoBzB,sBAAsB;IAYpC,OAAO,CAAC,6BAA6B;IAIrC,OAAO,CAAC,+BAA+B;IAIvC,OAAO,CAAC,wBAAwB;CAWjC"}

package/dist/database.js

@@ -0,0 +1,170 @@
+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 { DRIZZLE_DATABASE, DRIZZLE_DISPOSE, DRIZZLE_OPTIONS } from './tokens.js';
+import { createDrizzlePlatformStatusSnapshot } from './status.js';
+const TRANSACTION_NOT_SUPPORTED_ERROR = 'Transaction not supported: Drizzle database does not implement transaction.';
+const NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR = 'Nested Drizzle transaction options are not supported because the active transaction context is reused.';
+let _DrizzleDatabase;
+/**
+ * Transaction-aware Drizzle wrapper that integrates request scoping and shutdown handling with the Fluo runtime.
+ *
+ * @typeParam TDatabase Root Drizzle database handle registered in the module.
+ * @typeParam TTransactionDatabase Transaction-scoped database handle resolved inside `database.transaction(...)` callbacks.
+ * @typeParam TTransactionOptions Options forwarded to the underlying Drizzle transaction runner.
+ */
+class DrizzleDatabase {
+  static {
+    [_DrizzleDatabase, _initClass] = _applyDecs(this, [Inject(DRIZZLE_DATABASE, DRIZZLE_DISPOSE, DRIZZLE_OPTIONS)], []).c;
+  }
+  transactions = new AsyncLocalStorage();
+  activeRequestTransactions = new Set();
+  lifecycleState = 'ready';
+  constructor(database, dispose, databaseOptions = {
+    strictTransactions: false
+  }) {
+    this.database = database;
+    this.dispose = dispose;
+    this.databaseOptions = databaseOptions;
+  }
+
+  /**
+   * Returns the active transaction handle when present, otherwise the root Drizzle database handle.
+   *
+   * @example
+   * ```ts
+   * return db.current().select().from(users);
+   * ```
+   *
+   * @returns The transaction-scoped database inside an active boundary, or the root database outside one.
+   */
+  current() {
+    return this.transactions.getStore() ?? this.database;
+  }
+
+  /** Aborts active request transactions, waits for settlement, then runs the optional dispose hook. */
+  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 (this.dispose) {
+      await this.dispose(this.database);
+    }
+    this.lifecycleState = 'stopped';
+  }
+
+  /** Produces the shared persistence status snapshot for platform diagnostics surfaces. */
+  createPlatformStatusSnapshot() {
+    return createDrizzlePlatformStatusSnapshot({
+      activeRequestTransactions: this.activeRequestTransactions.size,
+      lifecycleState: this.lifecycleState,
+      strictTransactions: this.databaseOptions.strictTransactions,
+      supportsTransaction: typeof this.database.transaction === 'function'
+    });
+  }
+
+  /**
+   * Opens a Drizzle transaction boundary or reuses the current one when already inside a transaction.
+   *
+   * @example
+   * ```ts
+   * await db.transaction(async () => {
+   *   await db.current().insert(users).values(user);
+   * });
+   * ```
+   *
+   * @param fn Callback executed inside the transaction scope.
+   * @param options Optional transaction options forwarded to `database.transaction(...)`.
+   * @returns The callback result after the transaction finishes or the direct-execution fallback completes.
+   */
+  async transaction(fn, options) {
+    return this.executeTransaction(fn, options, false);
+  }
+
+  /**
+   * Opens an abort-aware request transaction boundary for the current HTTP request.
+   *
+   * @example
+   * ```ts
+   * await db.requestTransaction(async () => next.handle(), request.signal);
+   * ```
+   *
+   * @param fn Callback executed inside the request transaction scope.
+   * @param signal Optional abort signal linked to the request lifecycle.
+   * @param options Optional transaction options forwarded to `database.transaction(...)`.
+   * @returns The callback result after the request transaction finishes or the direct-execution fallback completes.
+   */
+  async requestTransaction(fn, signal, options) {
+    return this.executeTransaction(fn, options, true, signal);
+  }
+  async executeTransaction(fn, options, requestScoped, signal) {
+    const current = this.transactions.getStore();
+    if (current) {
+      if (options !== undefined) {
+        throw new Error(NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR);
+      }
+      if (requestScoped && signal) {
+        return raceWithAbort(fn, signal);
+      }
+      return fn();
+    }
+    const transactionRunner = this.resolveTransactionRunner();
+    if (!transactionRunner) {
+      if (requestScoped) {
+        return this.executeRequestFallback(fn, signal);
+      }
+      return fn();
+    }
+    if (!requestScoped) {
+      return transactionRunner(transactionDatabase => this.transactions.run(transactionDatabase, fn), options);
+    }
+    return this.executeRequestTransaction(transactionRunner, fn, options, signal);
+  }
+  async executeRequestTransaction(transactionRunner, fn, options, signal) {
+    const abortContext = createRequestAbortContext(signal);
+    const active = this.trackActiveRequestTransaction(abortContext.controller);
+    try {
+      return await transactionRunner(transactionDatabase => this.transactions.run(transactionDatabase, () => raceWithAbort(fn, abortContext.signal)), options);
+    } finally {
+      abortContext.cleanup();
+      this.untrackActiveRequestTransaction(active);
+    }
+  }
+  async executeRequestFallback(fn, signal) {
+    const abortContext = createRequestAbortContext(signal);
+    const active = this.trackActiveRequestTransaction(abortContext.controller);
+    try {
+      return await raceWithAbort(fn, abortContext.signal);
+    } finally {
+      abortContext.cleanup();
+      this.untrackActiveRequestTransaction(active);
+    }
+  }
+  trackActiveRequestTransaction(controller) {
+    return trackActiveRequestTransaction(this.activeRequestTransactions, controller);
+  }
+  untrackActiveRequestTransaction(handle) {
+    untrackActiveRequestTransaction(this.activeRequestTransactions, handle);
+  }
+  resolveTransactionRunner() {
+    if (typeof this.database.transaction !== 'function') {
+      if (this.databaseOptions.strictTransactions) {
+        throw new Error(TRANSACTION_NOT_SUPPORTED_ERROR);
+      }
+      return undefined;
+    }
+    return this.database.transaction.bind(this.database);
+  }
+  static {
+    _initClass();
+  }
+}
+export { _DrizzleDatabase as DrizzleDatabase };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './database.js';
+export * from './module.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,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,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 './database.js';
+export * from './module.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,13 @@
+import type { AsyncModuleOptions } from '@fluojs/core';
+import { type ModuleType } from '@fluojs/runtime';
+import type { DrizzleDatabaseLike, DrizzleModuleOptions } from './types.js';
+/**
+ * Module entrypoint for wiring a Drizzle database into the Fluo runtime lifecycle.
+ */
+export declare class DrizzleModule {
+    /** Creates a module definition from static Drizzle options. */
+    static forRoot<TDatabase extends DrizzleDatabaseLike<TTransactionDatabase, TTransactionOptions>, TTransactionDatabase = TDatabase, TTransactionOptions = unknown>(options: DrizzleModuleOptions<TDatabase, TTransactionDatabase, TTransactionOptions>): ModuleType;
+    /** Creates a module definition from DI-aware async Drizzle options. */
+    static forRootAsync<TDatabase extends DrizzleDatabaseLike<TTransactionDatabase, TTransactionOptions>, TTransactionDatabase = TDatabase, TTransactionOptions = unknown>(options: AsyncModuleOptions<DrizzleModuleOptions<TDatabase, TTransactionDatabase, 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,EAAE,MAAM,cAAc,CAAC;AAEvD,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAKhE,OAAO,KAAK,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0I5E;;GAEG;AACH,qBAAa,aAAa;IACxB,+DAA+D;IAC/D,MAAM,CAAC,OAAO,CACZ,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAChF,oBAAoB,GAAG,SAAS,EAChC,mBAAmB,GAAG,OAAO,EAC7B,OAAO,EAAE,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,GAAG,UAAU;IAIlG,uEAAuE;IACvE,MAAM,CAAC,YAAY,CACjB,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAChF,oBAAoB,GAAG,SAAS,EAChC,mBAAmB,GAAG,OAAO,EAC7B,OAAO,EAAE,kBAAkB,CAAC,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,CAAC,GAAG,UAAU;CAGvH"}

package/dist/module.js

@@ -0,0 +1,86 @@
+import { defineModule } from '@fluojs/runtime';
+import { DrizzleDatabase } from './database.js';
+import { DRIZZLE_DATABASE, DRIZZLE_DISPOSE, DRIZZLE_OPTIONS } from './tokens.js';
+import { DrizzleTransactionInterceptor } from './transaction.js';
+const DRIZZLE_NORMALIZED_OPTIONS = Symbol('fluo.drizzle.normalized-options');
+const DRIZZLE_MODULE_EXPORTS = [DrizzleDatabase, DrizzleTransactionInterceptor];
+function normalizeDrizzleModuleOptions(options) {
+  return {
+    ...options,
+    strictTransactions: options.strictTransactions ?? false
+  };
+}
+function createRuntimeOptionsProviderValue(strictTransactions) {
+  return {
+    strictTransactions
+  };
+}
+function createDrizzleRuntimeProviders(normalizedOptionsProvider) {
+  return [normalizedOptionsProvider, {
+    inject: [DRIZZLE_NORMALIZED_OPTIONS],
+    provide: DRIZZLE_DATABASE,
+    useFactory: options => options.database
+  }, {
+    inject: [DRIZZLE_NORMALIZED_OPTIONS],
+    provide: DRIZZLE_DISPOSE,
+    useFactory: options => options.dispose
+  }, {
+    inject: [DRIZZLE_NORMALIZED_OPTIONS],
+    provide: DRIZZLE_OPTIONS,
+    useFactory: options => createRuntimeOptionsProviderValue(options.strictTransactions)
+  }, DrizzleDatabase, DrizzleTransactionInterceptor];
+}
+function createMemoizedDrizzleOptionsResolver(options) {
+  let cachedResult;
+  return (...deps) => {
+    if (!cachedResult) {
+      cachedResult = Promise.resolve(options.useFactory(...deps)).then(resolved => normalizeDrizzleModuleOptions(resolved));
+    }
+    if (!cachedResult) {
+      throw new Error('Drizzle module options resolver initialization failed.');
+    }
+    return cachedResult;
+  };
+}
+function createDrizzleProvidersAsync(options) {
+  const resolveOptions = createMemoizedDrizzleOptionsResolver(options);
+  const normalizedOptionsProvider = {
+    inject: options.inject,
+    provide: DRIZZLE_NORMALIZED_OPTIONS,
+    scope: 'singleton',
+    useFactory: async (...deps) => resolveOptions(...deps)
+  };
+  return createDrizzleRuntimeProviders(normalizedOptionsProvider);
+}
+function buildDrizzleModule(options) {
+  class DrizzleRootModuleDefinition {}
+  return defineModule(DrizzleRootModuleDefinition, {
+    exports: DRIZZLE_MODULE_EXPORTS,
+    providers: createDrizzleRuntimeProviders({
+      provide: DRIZZLE_NORMALIZED_OPTIONS,
+      useValue: normalizeDrizzleModuleOptions(options)
+    })
+  });
+}
+function buildDrizzleModuleAsync(options) {
+  class DrizzleAsyncModuleDefinition {}
+  return defineModule(DrizzleAsyncModuleDefinition, {
+    exports: DRIZZLE_MODULE_EXPORTS,
+    providers: createDrizzleProvidersAsync(options)
+  });
+}
+
+/**
+ * Module entrypoint for wiring a Drizzle database into the Fluo runtime lifecycle.
+ */
+export class DrizzleModule {
+  /** Creates a module definition from static Drizzle options. */
+  static forRoot(options) {
+    return buildDrizzleModule(options);
+  }
+
+  /** Creates a module definition from DI-aware async Drizzle options. */
+  static forRootAsync(options) {
+    return buildDrizzleModuleAsync(options);
+  }
+}

package/dist/status.d.ts

@@ -0,0 +1,17 @@
+import type { PersistencePlatformStatusSnapshot } from '@fluojs/runtime';
+type DrizzlePlatformLifecycleState = 'ready' | 'shutting-down' | 'stopped';
+type DrizzlePlatformStatusSnapshotInput = {
+    activeRequestTransactions: number;
+    lifecycleState: DrizzlePlatformLifecycleState;
+    strictTransactions: boolean;
+    supportsTransaction: boolean;
+};
+/**
+ * Maps Drizzle lifecycle and transaction capability diagnostics into the shared persistence snapshot shape.
+ *
+ * @param input Current Drizzle ownership, readiness, and health inputs.
+ * @returns Platform-facing persistence status data for diagnostics surfaces.
+ */
+export declare function createDrizzlePlatformStatusSnapshot(input: DrizzlePlatformStatusSnapshotInput): 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,6BAA6B,GAAG,OAAO,GAAG,eAAe,GAAG,SAAS,CAAC;AAE3E,KAAK,kCAAkC,GAAG;IACxC,yBAAyB,EAAE,MAAM,CAAC;IAClC,cAAc,EAAE,6BAA6B,CAAC;IAC9C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAqDF;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,kCAAkC,GACxC,iCAAiC,CAgBnC"}

package/dist/status.js

@@ -0,0 +1,68 @@
+function createReadiness(input) {
+  if (input.lifecycleState === 'shutting-down') {
+    return {
+      critical: true,
+      reason: 'Drizzle integration is shutting down.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'stopped') {
+    return {
+      critical: true,
+      reason: 'Drizzle integration is stopped.',
+      status: 'not-ready'
+    };
+  }
+  if (input.strictTransactions && !input.supportsTransaction) {
+    return {
+      critical: true,
+      reason: 'Drizzle strictTransactions is enabled but database.transaction is unavailable.',
+      status: 'not-ready'
+    };
+  }
+  return {
+    critical: true,
+    status: 'ready'
+  };
+}
+function createHealth(input) {
+  if (input.lifecycleState === 'stopped') {
+    return {
+      reason: 'Drizzle integration has been disposed.',
+      status: 'unhealthy'
+    };
+  }
+  if (input.lifecycleState === 'shutting-down') {
+    return {
+      reason: 'Drizzle integration is draining request transactions during shutdown.',
+      status: 'degraded'
+    };
+  }
+  return {
+    status: 'healthy'
+  };
+}
+
+/**
+ * Maps Drizzle lifecycle and transaction capability diagnostics into the shared persistence snapshot shape.
+ *
+ * @param input Current Drizzle ownership, readiness, and health inputs.
+ * @returns Platform-facing persistence status data for diagnostics surfaces.
+ */
+export function createDrizzlePlatformStatusSnapshot(input) {
+  return {
+    details: {
+      activeRequestTransactions: input.activeRequestTransactions,
+      lifecycleState: input.lifecycleState,
+      strictTransactions: input.strictTransactions,
+      supportsTransaction: input.supportsTransaction,
+      transactionContext: 'als'
+    },
+    health: createHealth(input),
+    ownership: {
+      externallyManaged: true,
+      ownsResources: false
+    },
+    readiness: createReadiness(input)
+  };
+}

package/dist/tokens.d.ts

@@ -0,0 +1,7 @@
+/** Dependency-injection token for the raw Drizzle database handle. */
+export declare const DRIZZLE_DATABASE: unique symbol;
+/** Dependency-injection token for the optional Drizzle shutdown dispose hook. */
+export declare const DRIZZLE_DISPOSE: unique symbol;
+/** Dependency-injection token for normalized Drizzle runtime options. */
+export declare const DRIZZLE_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,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,eAAsC,CAAC;AACpE,iFAAiF;AACjF,eAAO,MAAM,eAAe,eAAqC,CAAC;AAClE,yEAAyE;AACzE,eAAO,MAAM,eAAe,eAAqC,CAAC"}

package/dist/tokens.js

@@ -0,0 +1,6 @@
+/** Dependency-injection token for the raw Drizzle database handle. */
+export const DRIZZLE_DATABASE = Symbol.for('fluo.drizzle.database');
+/** Dependency-injection token for the optional Drizzle shutdown dispose hook. */
+export const DRIZZLE_DISPOSE = Symbol.for('fluo.drizzle.dispose');
+/** Dependency-injection token for normalized Drizzle runtime options. */
+export const DRIZZLE_OPTIONS = Symbol.for('fluo.drizzle.options');

package/dist/transaction.d.ts

@@ -0,0 +1,25 @@
+import type { Interceptor, InterceptorContext } from '@fluojs/http';
+import { DrizzleDatabase } from './database.js';
+import type { DrizzleDatabaseLike } from './types.js';
+/**
+ * HTTP interceptor that wraps each request in a Drizzle request transaction boundary.
+ *
+ * @remarks
+ * Pair this with repository/service code that reads `DrizzleDatabase.current()` so downstream calls share the same
+ * request-scoped transaction handle.
+ */
+export declare class DrizzleTransactionInterceptor implements Interceptor {
+    private readonly database;
+    constructor(database: DrizzleDatabase<DrizzleDatabaseLike<unknown, unknown>, unknown, unknown>);
+    /**
+     * Runs the downstream handler inside a Drizzle 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,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;GAMG;AACH,qBACa,6BAA8B,YAAW,WAAW;IACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,eAAe,CAAC,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC;IAE/G;;;;;;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 { DrizzleDatabase } from './database.js';
+let _DrizzleTransactionIn;
+/**
+ * HTTP interceptor that wraps each request in a Drizzle request transaction boundary.
+ *
+ * @remarks
+ * Pair this with repository/service code that reads `DrizzleDatabase.current()` so downstream calls share the same
+ * request-scoped transaction handle.
+ */
+class DrizzleTransactionInterceptor {
+  static {
+    [_DrizzleTransactionIn, _initClass] = _applyDecs(this, [Inject(DrizzleDatabase)], []).c;
+  }
+  constructor(database) {
+    this.database = database;
+  }
+
+  /**
+   * Runs the downstream handler inside a Drizzle 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.database.requestTransaction(async () => next.handle(), context.requestContext.request.signal);
+  }
+  static {
+    _initClass();
+  }
+}
+export { _DrizzleTransactionIn as DrizzleTransactionInterceptor };

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+import type { MaybePromise } from '@fluojs/core';
+type DrizzleTransactionCallback<TTransactionDatabase, TResult> = (database: TTransactionDatabase) => Promise<TResult>;
+type DrizzleTransactionRunner<TTransactionDatabase, TTransactionOptions> = <T>(callback: DrizzleTransactionCallback<TTransactionDatabase, T>, options?: TTransactionOptions) => Promise<T>;
+/**
+ * Minimal Drizzle seam that exposes the optional transaction callback boundary used by the Fluo wrapper.
+ *
+ * @typeParam TTransactionDatabase Transaction handle shape passed into `database.transaction(...)` callbacks.
+ * @typeParam TTransactionOptions Options forwarded to the underlying Drizzle transaction runner.
+ */
+export interface DrizzleDatabaseLike<TTransactionDatabase = unknown, TTransactionOptions = unknown> {
+    transaction?: DrizzleTransactionRunner<TTransactionDatabase, TTransactionOptions>;
+}
+/**
+ * Module options for registering a Drizzle handle and optional shutdown disposal hook.
+ *
+ * @typeParam TDatabase Root Drizzle database handle registered in the module.
+ * @typeParam TTransactionDatabase Transaction-scoped database handle resolved by `current()`.
+ * @typeParam TTransactionOptions Options forwarded to `database.transaction(...)`.
+ */
+export interface DrizzleModuleOptions<TDatabase extends DrizzleDatabaseLike<TTransactionDatabase, TTransactionOptions>, TTransactionDatabase = TDatabase, TTransactionOptions = unknown> {
+    /** Root Drizzle database handle shared outside ambient transaction scopes. */
+    database: TDatabase;
+    /** Optional shutdown hook used to close pools or driver resources during application shutdown. */
+    dispose?: (database: TDatabase) => MaybePromise<void>;
+    /**
+     * Throws when transaction helpers are used against a database that does not expose `transaction(...)`.
+     *
+     * @remarks
+     * Leave this disabled when transaction helpers should fall back to direct execution.
+     */
+    strictTransactions?: boolean;
+}
+/**
+ * Public Drizzle wrapper contract exposed through dependency injection.
+ *
+ * @typeParam TDatabase Root Drizzle database handle registered in the module.
+ * @typeParam TTransactionDatabase Transaction-scoped database handle resolved inside transaction boundaries.
+ * @typeParam TTransactionOptions Options forwarded to `database.transaction(...)`.
+ */
+export interface DrizzleHandleProvider<TDatabase extends DrizzleDatabaseLike<TTransactionDatabase, TTransactionOptions>, TTransactionDatabase = TDatabase, TTransactionOptions = unknown> {
+    /** Returns the ambient transaction database when present, or the root Drizzle handle otherwise. */
+    current(): TDatabase | TTransactionDatabase;
+    /**
+     * 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 transaction options forwarded to `database.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 a Drizzle transaction boundary around `fn`.
+     *
+     * @param fn Callback executed within the transaction scope.
+     * @param options Optional transaction options forwarded to `database.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,0BAA0B,CAAC,oBAAoB,EAAE,OAAO,IAAI,CAAC,QAAQ,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtH,KAAK,wBAAwB,CAAC,oBAAoB,EAAE,mBAAmB,IAAI,CAAC,CAAC,EAC3E,QAAQ,EAAE,0BAA0B,CAAC,oBAAoB,EAAE,CAAC,CAAC,EAC7D,OAAO,CAAC,EAAE,mBAAmB,KAC1B,OAAO,CAAC,CAAC,CAAC,CAAC;AAEhB;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB,CAAC,oBAAoB,GAAG,OAAO,EAAE,mBAAmB,GAAG,OAAO;IAChG,WAAW,CAAC,EAAE,wBAAwB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,CAAC;CACnF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB,CAAC,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,oBAAoB,GAAG,SAAS,EAAE,mBAAmB,GAAG,OAAO;IACrL,8EAA8E;IAC9E,QAAQ,EAAE,SAAS,CAAC;IACpB,kGAAkG;IAClG,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;IACtD;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB,CAAC,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,oBAAoB,GAAG,SAAS,EAAE,mBAAmB,GAAG,OAAO;IACtL,mGAAmG;IACnG,OAAO,IAAI,SAAS,GAAG,oBAAoB,CAAC;IAC5C;;;;;;;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,62 @@
+{
+  "name": "@fluojs/drizzle",
+  "description": "Drizzle ORM integration for Fluo with ALS transaction context, async module factory, and optional dispose hook.",
+  "keywords": [
+    "fluo",
+    "drizzle",
+    "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/drizzle"
+  },
+  "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/runtime": "^1.0.0-beta.1",
+    "@fluojs/di": "^1.0.0-beta.1",
+    "@fluojs/core": "^1.0.0-beta.1",
+    "@fluojs/http": "^1.0.0-beta.1"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.30.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "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"
+  }
+}