@fluojs/drizzle 1.0.0-beta.3 → 1.0.0-beta.5

package/README.ko.md

@@ -107,6 +107,9 @@ class UsersController {}
 ### 종료와 상태 계약
 
 `DrizzleTransactionInterceptor`는 각 HTTP 요청을 `DrizzleDatabase.requestTransaction(...)`으로 실행합니다. 애플리케이션 종료 중에는 `DrizzleDatabase`가 아직 활성 상태인 요청 트랜잭션을 abort하고, 해당 transaction callback이 settle되거나 rollback될 때까지 기다린 뒤 선택적 `dispose(database)` hook을 실행합니다. 이 순서는 pool이나 외부 관리 리소스를 닫기 전에 driver가 rollback/cleanup 작업을 끝낼 수 있게 보장합니다.
+기존 요청 boundary 안에서 열린 중첩 `requestTransaction(...)` 호출은 활성 Drizzle transaction을 재사용하면서도 ambient request abort signal을 관찰합니다. 기존 수동 transaction boundary 안에서 열린 중첩 `requestTransaction(...)` 호출도 두 번째 Drizzle transaction을 열지 않고 shutdown settlement tracking에 참여하며, 해당 settlement handle은 바깥 수동 transaction이 settle될 때까지 tracking에 남아 shutdown이 `dispose(database)`를 실행하기 전에 그 바깥 경계까지 drain하게 합니다. 단, platform status activity count는 더 짧게 유지됩니다. 중첩 request callback이 settle되는 즉시, 바깥 수동 transaction이 계속 실행 중이어도 `details.activeRequestTransactions`는 감소합니다.
+종료가 시작된 뒤 새 `requestTransaction(...)` 호출은 거부되므로, 종료 boundary를 지난 뒤 시작되는 늦은 요청 트랜잭션보다 dispose가 먼저 실행되는 상황을 방지합니다.
+요청 callback이 완료된 뒤 underlying Drizzle transaction runner가 commit 또는 rollback을 끝내기 전에 request signal이 abort되면, `requestTransaction(...)`은 먼저 해당 runner가 settle될 때까지 기다린 다음 abort reason으로 reject합니다. 이 동작은 Drizzle cleanup을 request cancellation과 직렬화하면서, 완료된 callback 결과를 반환하는 대신 늦은 request abort를 caller에게 드러냅니다.
 
 `createDrizzlePlatformStatusSnapshot(...)`과 `DrizzleDatabase.createPlatformStatusSnapshot()`은 같은 계약을 진단 surface에 노출합니다.
 
@@ -141,12 +144,14 @@ defineModule(ManualDrizzleModule, {
 - `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`
 - `DrizzleDatabase`
 - `DrizzleTransactionInterceptor`
-- `DRIZZLE_DATABASE`, `DRIZZLE_DISPOSE`, `DRIZZLE_OPTIONS`
+- `DRIZZLE_DATABASE`, `DRIZZLE_DISPOSE`, `DRIZZLE_HANDLE_PROVIDER`, `DRIZZLE_OPTIONS`
 - `createDrizzlePlatformStatusSnapshot(...)`
 - `DrizzleDatabaseLike`
 - `DrizzleModuleOptions`
 - `DrizzleHandleProvider`
 
+`DRIZZLE_HANDLE_PROVIDER`는 lifecycle-aware `DrizzleDatabase` wrapper를 가리키는 alias token입니다. `@fluojs/terminus` 같은 health integration은 이 token을 통해 raw database ping으로 fallback하기 전에 `createPlatformStatusSnapshot()`을 읽습니다.
+
 ### `DrizzleModule`
 
 - `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`

package/README.md

@@ -107,6 +107,9 @@ class UsersController {}
 ### Shutdown and status contracts
 
 `DrizzleTransactionInterceptor` runs each HTTP request through `DrizzleDatabase.requestTransaction(...)`. During application shutdown, `DrizzleDatabase` aborts any still-active request transaction, waits for its transaction callback to settle or roll back, and only then runs the optional `dispose(database)` hook. This ordering lets drivers finish rollback/cleanup work before pools or externally managed resources are closed.
+Nested `requestTransaction(...)` calls opened inside an existing request boundary observe the ambient request abort signal while still reusing the active Drizzle transaction. Nested `requestTransaction(...)` calls opened inside an existing manual transaction boundary also join shutdown settlement tracking without opening a second Drizzle transaction, and their settlement handle remains tracked until the outer manual transaction settles so shutdown drains that outer boundary before `dispose(database)` runs. The platform status activity count is intentionally shorter lived: once the nested request callback settles, `details.activeRequestTransactions` is decremented even if the outer manual transaction continues running.
+New `requestTransaction(...)` calls are rejected once shutdown begins, so disposal cannot overtake a late request transaction that starts after the shutdown boundary is crossed.
+If the request signal aborts after the request callback has completed but before the underlying Drizzle transaction runner finishes committing or rolling back, `requestTransaction(...)` waits for that runner to settle first and then rejects with the abort reason. This keeps Drizzle cleanup serialized with request cancellation while making the late request abort visible to the caller instead of returning the completed callback result.
 
 `createDrizzlePlatformStatusSnapshot(...)` and `DrizzleDatabase.createPlatformStatusSnapshot()` expose the same contract to diagnostics surfaces:
 
@@ -141,12 +144,14 @@ defineModule(ManualDrizzleModule, {
 - `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`
 - `DrizzleDatabase`
 - `DrizzleTransactionInterceptor`
-- `DRIZZLE_DATABASE`, `DRIZZLE_DISPOSE`, `DRIZZLE_OPTIONS`
+- `DRIZZLE_DATABASE`, `DRIZZLE_DISPOSE`, `DRIZZLE_HANDLE_PROVIDER`, `DRIZZLE_OPTIONS`
 - `createDrizzlePlatformStatusSnapshot(...)`
 - `DrizzleDatabaseLike`
 - `DrizzleModuleOptions`
 - `DrizzleHandleProvider`
 
+`DRIZZLE_HANDLE_PROVIDER` is an alias token for the lifecycle-aware `DrizzleDatabase` wrapper. Health integrations such as `@fluojs/terminus` use this token to read `createPlatformStatusSnapshot()` before falling back to raw database pings.
+
 ### `DrizzleModule`
 
 - `DrizzleModule.forRoot(options)` / `DrizzleModule.forRootAsync(options)`

package/dist/database.d.ts

@@ -16,6 +16,7 @@ export declare class DrizzleDatabase<TDatabase extends DrizzleDatabaseLike<TTran
     private readonly databaseOptions;
     private readonly transactions;
     private readonly activeRequestTransactions;
+    private activeRequestTransactionStatusCount;
     private lifecycleState;
     constructor(database: TDatabase, dispose?: ((database: TDatabase) => Promise<void> | void) | undefined, databaseOptions?: DrizzleRuntimeOptions);
     /**
@@ -64,9 +65,13 @@ export declare class DrizzleDatabase<TDatabase extends DrizzleDatabaseLike<TTran
     requestTransaction<T>(fn: () => Promise<T>, signal?: AbortSignal, options?: TTransactionOptions): Promise<T>;
     private executeTransaction;
     private executeRequestTransaction;
+    private executeNestedRequestTransaction;
     private executeRequestFallback;
+    private assertRequestTransactionsAvailable;
+    private throwIfRequestAborted;
     private trackActiveRequestTransaction;
     private untrackActiveRequestTransaction;
+    private markRequestTransactionInactiveForStatus;
     private resolveTransactionRunner;
 }
 export {};

package/dist/database.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../src/database.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAK7D,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAuBpB,KAAK,qBAAqB,GAAG;IAC3B,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AA8CF;;;;;;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;IAQ3G,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe;IARlC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqE;IAClG,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,mCAAmC,CAAK;IAChD,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;IAiB5C,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;YAmDlB,yBAAyB;YA8BzB,+BAA+B;YA6C/B,sBAAsB;IAkBpC,OAAO,CAAC,kCAAkC;IAM1C,OAAO,CAAC,qBAAqB;IAM7B,OAAO,CAAC,6BAA6B;IAOrC,OAAO,CAAC,+BAA+B;IAKvC,OAAO,CAAC,uCAAuC;IAO/C,OAAO,CAAC,wBAAwB;CAWjC"}

package/dist/database.js

@@ -5,13 +5,46 @@ function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e =
 function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
 function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { createRequestAbortContext, raceWithAbort, trackActiveRequestTransaction, untrackActiveRequestTransaction } from '@fluojs/runtime';
+import { createAbortError, createRequestAbortContext, raceWithAbort, trackActiveRequestTransaction, untrackActiveRequestTransaction } from '@fluojs/runtime';
 import { Inject } from '@fluojs/core';
 import { 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;
+const REQUEST_TRANSACTION_UNAVAILABLE_ERROR = 'Drizzle request transactions are not available during shutdown.';
+function createRequestAbortSignalView(parentSignal, signal) {
+  if (!signal) {
+    return {
+      cleanup() {},
+      signal: parentSignal
+    };
+  }
+  const controller = new AbortController();
+  const forwardParentAbort = () => controller.abort(parentSignal.reason);
+  const forwardRequestAbort = () => controller.abort(signal.reason);
+  if (parentSignal.aborted) {
+    forwardParentAbort();
+  } else {
+    parentSignal.addEventListener('abort', forwardParentAbort, {
+      once: true
+    });
+  }
+  if (signal.aborted) {
+    forwardRequestAbort();
+  } else {
+    signal.addEventListener('abort', forwardRequestAbort, {
+      once: true
+    });
+  }
+  return {
+    cleanup() {
+      parentSignal.removeEventListener('abort', forwardParentAbort);
+      signal.removeEventListener('abort', forwardRequestAbort);
+    },
+    signal: controller.signal
+  };
+}
+
 /**
  * Transaction-aware Drizzle wrapper that integrates request scoping and shutdown handling with the Fluo runtime.
  *
@@ -19,12 +52,14 @@ let _DrizzleDatabase;
  * @typeParam TTransactionDatabase Transaction-scoped database handle resolved inside `database.transaction(...)` callbacks.
  * @typeParam TTransactionOptions Options forwarded to the underlying Drizzle transaction runner.
  */
+let _DrizzleDatabase;
 class DrizzleDatabase {
   static {
     [_DrizzleDatabase, _initClass] = _applyDecs(this, [Inject(DRIZZLE_DATABASE, DRIZZLE_DISPOSE, DRIZZLE_OPTIONS)], []).c;
   }
   transactions = new AsyncLocalStorage();
   activeRequestTransactions = new Set();
+  activeRequestTransactionStatusCount = 0;
   lifecycleState = 'ready';
   constructor(database, dispose, databaseOptions = {
     strictTransactions: false
@@ -45,16 +80,17 @@ class DrizzleDatabase {
    * @returns The transaction-scoped database inside an active boundary, or the root database outside one.
    */
   current() {
-    return this.transactions.getStore() ?? this.database;
+    return this.transactions.getStore()?.database ?? 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) {
+    const activeRequestTransactions = Array.from(this.activeRequestTransactions);
+    for (const transaction of activeRequestTransactions) {
       transaction.abort(new Error('Application shutdown interrupted an open request transaction.'));
     }
-    await Promise.allSettled(Array.from(this.activeRequestTransactions, transaction => transaction.settled));
+    await Promise.allSettled(activeRequestTransactions.map(transaction => transaction.settled));
     if (this.dispose) {
       await this.dispose(this.database);
     }
@@ -64,7 +100,7 @@ class DrizzleDatabase {
   /** Produces the shared persistence status snapshot for platform diagnostics surfaces. */
   createPlatformStatusSnapshot() {
     return createDrizzlePlatformStatusSnapshot({
-      activeRequestTransactions: this.activeRequestTransactions.size,
+      activeRequestTransactions: this.activeRequestTransactionStatusCount,
       lifecycleState: this.lifecycleState,
       strictTransactions: this.databaseOptions.strictTransactions,
       supportsTransaction: typeof this.database.transaction === 'function'
@@ -111,8 +147,8 @@ class DrizzleDatabase {
       if (options !== undefined) {
         throw new Error(NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR);
       }
-      if (requestScoped && signal) {
-        return raceWithAbort(fn, signal);
+      if (requestScoped) {
+        return this.executeNestedRequestTransaction(current, fn, signal);
       }
       return fn();
     }
@@ -124,36 +160,108 @@ class DrizzleDatabase {
       return fn();
     }
     if (!requestScoped) {
-      return transactionRunner(transactionDatabase => this.transactions.run(transactionDatabase, fn), options);
+      const deferredRequestTransactionSettlements = new Set();
+      try {
+        return await transactionRunner(transactionDatabase => this.transactions.run({
+          database: transactionDatabase,
+          deferredRequestTransactionSettlements
+        }, fn), options);
+      } finally {
+        for (const handle of deferredRequestTransactionSettlements) {
+          this.untrackActiveRequestTransaction(handle);
+        }
+      }
     }
     return this.executeRequestTransaction(transactionRunner, fn, options, signal);
   }
   async executeRequestTransaction(transactionRunner, fn, options, signal) {
+    this.assertRequestTransactionsAvailable();
     const abortContext = createRequestAbortContext(signal);
     const active = this.trackActiveRequestTransaction(abortContext.controller);
     try {
-      return await transactionRunner(transactionDatabase => this.transactions.run(transactionDatabase, () => raceWithAbort(fn, abortContext.signal)), options);
+      const result = await transactionRunner(transactionDatabase => this.transactions.run({
+        database: transactionDatabase,
+        requestAbortSignal: abortContext.signal
+      }, () => raceWithAbort(fn, abortContext.signal)), options);
+      this.throwIfRequestAborted(abortContext.signal);
+      return result;
     } finally {
       abortContext.cleanup();
       this.untrackActiveRequestTransaction(active);
     }
   }
+  async executeNestedRequestTransaction(current, fn, signal) {
+    if (current.requestAbortSignal) {
+      const abortSignalView = createRequestAbortSignalView(current.requestAbortSignal, signal);
+      try {
+        const result = await raceWithAbort(fn, abortSignalView.signal);
+        this.throwIfRequestAborted(abortSignalView.signal);
+        return result;
+      } finally {
+        abortSignalView.cleanup();
+      }
+    }
+    this.assertRequestTransactionsAvailable();
+    const abortContext = createRequestAbortContext(signal);
+    const active = this.trackActiveRequestTransaction(abortContext.controller);
+    current.deferredRequestTransactionSettlements?.add(active);
+    try {
+      const result = await this.transactions.run({
+        database: current.database,
+        requestAbortSignal: abortContext.signal
+      }, () => raceWithAbort(fn, abortContext.signal));
+      this.throwIfRequestAborted(abortContext.signal);
+      return result;
+    } finally {
+      abortContext.cleanup();
+      if (current.deferredRequestTransactionSettlements) {
+        this.markRequestTransactionInactiveForStatus(active);
+      } else {
+        this.untrackActiveRequestTransaction(active);
+      }
+    }
+  }
   async executeRequestFallback(fn, signal) {
+    this.assertRequestTransactionsAvailable();
     const abortContext = createRequestAbortContext(signal);
     const active = this.trackActiveRequestTransaction(abortContext.controller);
     try {
-      return await raceWithAbort(fn, abortContext.signal);
+      const result = await raceWithAbort(fn, abortContext.signal);
+      this.throwIfRequestAborted(abortContext.signal);
+      return result;
     } finally {
       abortContext.cleanup();
       this.untrackActiveRequestTransaction(active);
     }
   }
+  assertRequestTransactionsAvailable() {
+    if (this.lifecycleState !== 'ready') {
+      throw new Error(REQUEST_TRANSACTION_UNAVAILABLE_ERROR);
+    }
+  }
+  throwIfRequestAborted(signal) {
+    if (signal.aborted) {
+      throw createAbortError(signal.reason);
+    }
+  }
   trackActiveRequestTransaction(controller) {
-    return trackActiveRequestTransaction(this.activeRequestTransactions, controller);
+    const handle = trackActiveRequestTransaction(this.activeRequestTransactions, controller);
+    this.activeRequestTransactionStatusCount += 1;
+    return {
+      ...handle,
+      statusActive: true
+    };
   }
   untrackActiveRequestTransaction(handle) {
+    this.markRequestTransactionInactiveForStatus(handle);
     untrackActiveRequestTransaction(this.activeRequestTransactions, handle);
   }
+  markRequestTransactionInactiveForStatus(handle) {
+    if (handle.statusActive) {
+      this.activeRequestTransactionStatusCount -= 1;
+      handle.statusActive = false;
+    }
+  }
   resolveTransactionRunner() {
     if (typeof this.database.transaction !== 'function') {
       if (this.databaseOptions.strictTransactions) {

package/dist/module.d.ts.map

@@ -1 +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;AAc5E,KAAK,yBAAyB,CAC5B,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAChF,oBAAoB,EACpB,mBAAmB,IACjB,kBAAkB,CAAC,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,QAAQ,CAAC,CAAC,GAChH,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,QAAQ,CAAC,CAAC;AAgI7F;;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,yBAAyB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,GAAG,UAAU;CAGxG"}
+{"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;AAc5E,KAAK,yBAAyB,CAC5B,SAAS,SAAS,mBAAmB,CAAC,oBAAoB,EAAE,mBAAmB,CAAC,EAChF,oBAAoB,EACpB,mBAAmB,IACjB,kBAAkB,CAAC,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,QAAQ,CAAC,CAAC,GAChH,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,EAAE,QAAQ,CAAC,CAAC;AAoI7F;;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,yBAAyB,CAAC,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,CAAC,GAAG,UAAU;CAGxG"}

package/dist/module.js

@@ -1,9 +1,9 @@
 import { defineModule } from '@fluojs/runtime';
 import { DrizzleDatabase } from './database.js';
-import { DRIZZLE_DATABASE, DRIZZLE_DISPOSE, DRIZZLE_OPTIONS } from './tokens.js';
+import { DRIZZLE_DATABASE, DRIZZLE_DISPOSE, DRIZZLE_HANDLE_PROVIDER, 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];
+const DRIZZLE_MODULE_EXPORTS = [DrizzleDatabase, DrizzleTransactionInterceptor, DRIZZLE_HANDLE_PROVIDER];
 function normalizeDrizzleModuleOptions(options) {
   return {
     ...options,
@@ -28,7 +28,10 @@ function createDrizzleRuntimeProviders(normalizedOptionsProvider) {
     inject: [DRIZZLE_NORMALIZED_OPTIONS],
     provide: DRIZZLE_OPTIONS,
     useFactory: options => createRuntimeOptionsProviderValue(options.strictTransactions)
-  }, DrizzleDatabase, DrizzleTransactionInterceptor];
+  }, DrizzleDatabase, {
+    provide: DRIZZLE_HANDLE_PROVIDER,
+    useExisting: DrizzleDatabase
+  }, DrizzleTransactionInterceptor];
 }
 function createMemoizedDrizzleOptionsResolver(options) {
   let cachedResult;

package/dist/tokens.d.ts

@@ -1,5 +1,7 @@
 /** Dependency-injection token for the raw Drizzle database handle. */
 export declare const DRIZZLE_DATABASE: unique symbol;
+/** Dependency-injection token for the lifecycle-aware Drizzle database wrapper. */
+export declare const DRIZZLE_HANDLE_PROVIDER: 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. */

package/dist/tokens.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,eAAsC,CAAC;AACpE,mFAAmF;AACnF,eAAO,MAAM,uBAAuB,eAA6C,CAAC;AAClF,iFAAiF;AACjF,eAAO,MAAM,eAAe,eAAqC,CAAC;AAClE,yEAAyE;AACzE,eAAO,MAAM,eAAe,eAAqC,CAAC"}

package/dist/tokens.js

@@ -1,5 +1,7 @@
 /** Dependency-injection token for the raw Drizzle database handle. */
 export const DRIZZLE_DATABASE = Symbol.for('fluo.drizzle.database');
+/** Dependency-injection token for the lifecycle-aware Drizzle database wrapper. */
+export const DRIZZLE_HANDLE_PROVIDER = Symbol.for('fluo.drizzle.handle-provider');
 /** 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. */

package/package.json

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