@fluojs/mongoose 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,123 @@
+# @fluojs/mongoose
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo 애플리케이션을 위한 Mongoose 라이프사이클 및 세션 기반 트랜잭션 컨텍스트 모듈입니다. Mongoose 연결을 모듈 시스템에 연결하여 자동 연결 관리 및 선택적 요청 범위 트랜잭션을 제공합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [공통 패턴](#공통-패턴)
+- [공개 API](#공개-api)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+pnpm add @fluojs/mongoose
+# mongoose도 함께 설치되어 있어야 합니다.
+pnpm add mongoose
+```
+
+## 사용 시점
+
+- Mongoose를 MongoDB ODM으로 사용하면서 fluo의 의존성 주입 및 라이프사이클 훅과 통합하고 싶을 때.
+- 서비스 전반에서 MongoDB 세션과 트랜잭션을 중앙에서 관리하고 싶을 때.
+- 애플리케이션 종료 시 자동 연결 정리(dispose)가 필요할 때.
+
+## 빠른 시작
+
+루트 모듈에 Mongoose 연결 인스턴스를 전달하여 `MongooseModule`을 등록합니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { MongooseModule } from '@fluojs/mongoose';
+import mongoose from 'mongoose';
+
+const connection = mongoose.createConnection('mongodb://localhost:27017/test');
+
+@Module({
+  imports: [
+    MongooseModule.forRoot({
+      connection,
+      dispose: async (conn) => await conn.close(),
+    }),
+  ],
+})
+class AppModule {}
+```
+
+## 공통 패턴
+
+### `MongooseConnection`을 통한 연결 접근
+
+`MongooseConnection` 래퍼는 기본 Mongoose 연결에 대한 접근을 제공합니다.
+
+```typescript
+import { MongooseConnection } from '@fluojs/mongoose';
+
+export class UserRepository {
+  constructor(private readonly conn: MongooseConnection) {}
+
+  async findById(id: string) {
+    const User = this.conn.current().model('User');
+    return User.findById(id);
+  }
+}
+```
+
+### 수동 트랜잭션과 세션
+
+`conn.transaction()`을 사용하여 세션을 관리합니다. Prisma와 달리 Mongoose는 각 작업에 세션을 명시적으로 전달해야 합니다.
+
+```typescript
+await this.conn.transaction(async () => {
+  const session = this.conn.currentSession();
+  const User = this.conn.current().model('User');
+  
+  // 작업에 세션을 명시적으로 전달
+  await User.create([{ name: 'Ada' }], { session });
+});
+```
+
+### 자동 요청 트랜잭션
+
+컨트롤러나 메서드에 `MongooseTransactionInterceptor`를 적용하면 전체 요청을 자동으로 MongoDB 세션으로 감쌉니다.
+
+```typescript
+import { UseInterceptors } from '@fluojs/http';
+import { MongooseTransactionInterceptor } from '@fluojs/mongoose';
+
+@UseInterceptors(MongooseTransactionInterceptor)
+class UserController {}
+```
+
+## 공개 API
+
+- `MongooseModule.forRoot(options)` / `MongooseModule.forRootAsync(options)`
+- `MongooseConnection`
+- `MongooseTransactionInterceptor`
+- `MONGOOSE_CONNECTION`, `MONGOOSE_DISPOSE`, `MONGOOSE_OPTIONS`
+- `createMongooseProviders(options)`
+- `createMongoosePlatformStatusSnapshot(...)`
+
+### 관련 export 타입
+
+- `MongooseModuleOptions<TConnection>`
+- `MongooseConnectionLike`
+- `MongooseSessionLike`
+
+## 관련 패키지
+
+- `@fluojs/runtime`: 애플리케이션 라이프사이클 및 종료 훅을 관리합니다.
+- `@fluojs/http`: 인터셉터 시스템을 제공합니다.
+- `@fluojs/prisma` / `@fluojs/drizzle`: 대안 데이터베이스 통합 모듈입니다.
+
+## 예제 소스
+
+- `packages/mongoose/src/vertical-slice.test.ts`: 표준 DTO → 서비스 → 리포지토리 → Mongoose 흐름 예제.
+- `packages/mongoose/src/module.test.ts`: 모듈 등록과 수명 주기 계약 예제.
+- `packages/mongoose/src/public-api.test.ts`: 공개 export 검증 예제.

package/README.md

@@ -0,0 +1,113 @@
+# @fluojs/mongoose
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Mongoose integration for fluo with session-aware transaction handling and lifecycle-friendly connection management.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+- [Public API](#public-api)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+pnpm add @fluojs/mongoose
+pnpm add mongoose
+```
+
+## When to Use
+
+- when Mongoose should plug into the same DI and application lifecycle as the rest of the app
+- when MongoDB sessions and transactions need one shared wrapper instead of ad hoc session plumbing in every service
+- when request-scoped transactions should be opt-in through an interceptor
+
+## Quick Start
+
+```ts
+import { Module } from '@fluojs/core';
+import { MongooseModule } from '@fluojs/mongoose';
+import mongoose from 'mongoose';
+
+const connection = mongoose.createConnection('mongodb://localhost:27017/test');
+
+@Module({
+  imports: [
+    MongooseModule.forRoot({
+      connection,
+      dispose: async (conn) => conn.close(),
+    }),
+  ],
+})
+class AppModule {}
+```
+
+## Common Patterns
+
+### Access the connection through `MongooseConnection`
+
+```ts
+import { MongooseConnection } from '@fluojs/mongoose';
+
+export class UserRepository {
+  constructor(private readonly conn: MongooseConnection) {}
+
+  async findById(id: string) {
+    const User = this.conn.current().model('User');
+    return User.findById(id);
+  }
+}
+```
+
+### Manual transactions still need explicit sessions
+
+```ts
+await this.conn.transaction(async () => {
+  const session = this.conn.currentSession();
+  const User = this.conn.current().model('User');
+
+  await User.create([{ name: 'Ada' }], { session });
+});
+```
+
+### Request-scoped transactions
+
+```ts
+import { UseInterceptors } from '@fluojs/http';
+import { MongooseTransactionInterceptor } from '@fluojs/mongoose';
+
+@UseInterceptors(MongooseTransactionInterceptor)
+class UserController {}
+```
+
+## Public API
+
+- `MongooseModule.forRoot(options)` / `MongooseModule.forRootAsync(options)`
+- `MongooseConnection`
+- `MongooseTransactionInterceptor`
+- `MONGOOSE_CONNECTION`, `MONGOOSE_DISPOSE`, `MONGOOSE_OPTIONS`
+- `createMongooseProviders(options)`
+- `createMongoosePlatformStatusSnapshot(...)`
+
+### Related exported types
+
+- `MongooseModuleOptions<TConnection>`
+- `MongooseConnectionLike`
+- `MongooseSessionLike`
+
+## Related Packages
+
+- `@fluojs/runtime`: manages startup and shutdown hooks
+- `@fluojs/http`: provides the interceptor chain for request transactions
+- `@fluojs/prisma` and `@fluojs/drizzle`: alternate database integrations with different transaction models
+
+## Example Sources
+
+- `packages/mongoose/src/vertical-slice.test.ts`
+- `packages/mongoose/src/module.test.ts`
+- `packages/mongoose/src/public-api.test.ts`

package/dist/connection.d.ts

@@ -0,0 +1,77 @@
+import type { OnApplicationShutdown } from '@fluojs/runtime';
+import type { MongooseConnectionLike, MongooseHandleProvider, MongooseSessionLike } from './types.js';
+type MongooseRuntimeOptions = {
+    strictTransactions: boolean;
+};
+/**
+ * Session-aware Mongoose wrapper that integrates request scoping and shutdown handling with the Fluo runtime.
+ *
+ * @typeParam TConnection Root Mongoose connection shape registered in the module.
+ */
+export declare class MongooseConnection<TConnection extends MongooseConnectionLike = MongooseConnectionLike> implements MongooseHandleProvider<TConnection>, OnApplicationShutdown {
+    private readonly connection;
+    private readonly dispose?;
+    private readonly connectionOptions;
+    private readonly sessions;
+    private readonly activeRequestTransactions;
+    private lifecycleState;
+    constructor(connection: TConnection, dispose?: ((connection: TConnection) => Promise<void> | void) | undefined, connectionOptions?: MongooseRuntimeOptions);
+    /**
+     * Returns the root Mongoose connection handle.
+     *
+     * @example
+     * ```ts
+     * const User = conn.current().model('User');
+     * ```
+     *
+     * @returns The registered Mongoose connection.
+     */
+    current(): TConnection;
+    /**
+     * Returns the active Mongoose session for the current async context, if one exists.
+     *
+     * @example
+     * ```ts
+     * const session = conn.currentSession();
+     * ```
+     *
+     * @returns The ambient session inside a transaction boundary, or `undefined` outside one.
+     */
+    currentSession(): MongooseSessionLike | undefined;
+    /** 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 Mongoose session transaction boundary or reuses the current one when already active.
+     *
+     * @example
+     * ```ts
+     * await conn.transaction(async () => {
+     *   await User.create([{ name: 'Ada' }], { session: conn.currentSession() });
+     * });
+     * ```
+     *
+     * @param fn Callback executed within the transaction scope.
+     * @returns The callback result after the session transaction finishes or the direct-execution fallback completes.
+     */
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Opens an abort-aware request transaction boundary for the current HTTP request.
+     *
+     * @example
+     * ```ts
+     * await conn.requestTransaction(async () => next.handle(), request.signal);
+     * ```
+     *
+     * @param fn Callback executed within the request transaction scope.
+     * @param signal Optional abort signal linked to the request lifecycle.
+     * @returns The callback result after the request transaction finishes or the direct-execution fallback completes.
+     */
+    requestTransaction<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    private trackActiveRequestTransaction;
+    private untrackActiveRequestTransaction;
+    private resolveSession;
+}
+export {};
+//# sourceMappingURL=connection.d.ts.map

package/dist/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../src/connection.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAK7D,OAAO,KAAK,EACV,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAcpB,KAAK,sBAAsB,GAAG;IAC5B,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAmBF;;;;GAIG;AACH,qBACa,kBAAkB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB,CACjG,YAAW,sBAAsB,CAAC,WAAW,CAAC,EAAE,qBAAqB;IAOnE,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAPpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgD;IACzE,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAuC;IACjF,OAAO,CAAC,cAAc,CAAkD;gBAGrD,UAAU,EAAE,WAAW,EACvB,OAAO,CAAC,GAAE,CAAC,UAAU,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,aAAA,EAC3D,iBAAiB,GAAE,sBAAsD;IAG5F;;;;;;;;;OASG;IACH,OAAO,IAAI,WAAW;IAItB;;;;;;;;;OASG;IACH,cAAc,IAAI,mBAAmB,GAAG,SAAS;IAIjD,qGAAqG;IAC/F,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5C,yFAAyF;IACzF,4BAA4B;IAU5B;;;;;;;;;;;;OAYG;IACG,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAoBtD;;;;;;;;;;;OAWG;IACG,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC;IAoCnF,OAAO,CAAC,6BAA6B;IAIrC,OAAO,CAAC,+BAA+B;YAIzB,cAAc;CAW7B"}

package/dist/connection.js

@@ -0,0 +1,189 @@
+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 { MONGOOSE_CONNECTION, MONGOOSE_DISPOSE, MONGOOSE_OPTIONS } from './tokens.js';
+import { createMongoosePlatformStatusSnapshot } from './status.js';
+const TRANSACTIONS_NOT_SUPPORTED_ERROR = 'Transaction not supported: Mongoose connection does not implement startSession.';
+async function executeSessionTransaction(session, fn) {
+  try {
+    await session.startTransaction();
+    const result = await fn();
+    await session.commitTransaction();
+    return result;
+  } catch (error) {
+    try {
+      await session.abortTransaction();
+    } catch (abortError) {
+      void abortError;
+    }
+    throw error;
+  }
+}
+
+/**
+ * Session-aware Mongoose wrapper that integrates request scoping and shutdown handling with the Fluo runtime.
+ *
+ * @typeParam TConnection Root Mongoose connection shape registered in the module.
+ */
+let _MongooseConnection;
+class MongooseConnection {
+  static {
+    [_MongooseConnection, _initClass] = _applyDecs(this, [Inject(MONGOOSE_CONNECTION, MONGOOSE_DISPOSE, MONGOOSE_OPTIONS)], []).c;
+  }
+  sessions = new AsyncLocalStorage();
+  activeRequestTransactions = new Set();
+  lifecycleState = 'ready';
+  constructor(connection, dispose, connectionOptions = {
+    strictTransactions: false
+  }) {
+    this.connection = connection;
+    this.dispose = dispose;
+    this.connectionOptions = connectionOptions;
+  }
+
+  /**
+   * Returns the root Mongoose connection handle.
+   *
+   * @example
+   * ```ts
+   * const User = conn.current().model('User');
+   * ```
+   *
+   * @returns The registered Mongoose connection.
+   */
+  current() {
+    return this.connection;
+  }
+
+  /**
+   * Returns the active Mongoose session for the current async context, if one exists.
+   *
+   * @example
+   * ```ts
+   * const session = conn.currentSession();
+   * ```
+   *
+   * @returns The ambient session inside a transaction boundary, or `undefined` outside one.
+   */
+  currentSession() {
+    return this.sessions.getStore();
+  }
+
+  /** 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.connection);
+    }
+    this.lifecycleState = 'stopped';
+  }
+
+  /** Produces the shared persistence status snapshot for platform diagnostics surfaces. */
+  createPlatformStatusSnapshot() {
+    return createMongoosePlatformStatusSnapshot({
+      activeRequestTransactions: this.activeRequestTransactions.size,
+      hasActiveSession: this.sessions.getStore() !== undefined,
+      lifecycleState: this.lifecycleState,
+      strictTransactions: this.connectionOptions.strictTransactions,
+      supportsStartSession: typeof this.connection.startSession === 'function'
+    });
+  }
+
+  /**
+   * Opens a Mongoose session transaction boundary or reuses the current one when already active.
+   *
+   * @example
+   * ```ts
+   * await conn.transaction(async () => {
+   *   await User.create([{ name: 'Ada' }], { session: conn.currentSession() });
+   * });
+   * ```
+   *
+   * @param fn Callback executed within the transaction scope.
+   * @returns The callback result after the session transaction finishes or the direct-execution fallback completes.
+   */
+  async transaction(fn) {
+    const currentSession = this.sessions.getStore();
+    if (currentSession) {
+      return fn();
+    }
+    const session = await this.resolveSession();
+    if (!session) {
+      return fn();
+    }
+    try {
+      return await this.sessions.run(session, () => executeSessionTransaction(session, () => this.sessions.run(session, fn)));
+    } finally {
+      await session.endSession();
+    }
+  }
+
+  /**
+   * Opens an abort-aware request transaction boundary for the current HTTP request.
+   *
+   * @example
+   * ```ts
+   * await conn.requestTransaction(async () => next.handle(), request.signal);
+   * ```
+   *
+   * @param fn Callback executed within the request transaction scope.
+   * @param signal Optional abort signal linked to the request lifecycle.
+   * @returns The callback result after the request transaction finishes or the direct-execution fallback completes.
+   */
+  async requestTransaction(fn, signal) {
+    const currentSession = this.sessions.getStore();
+    if (currentSession) {
+      if (signal) {
+        return raceWithAbort(fn, signal);
+      }
+      return fn();
+    }
+    const abortContext = createRequestAbortContext(signal);
+    const active = this.trackActiveRequestTransaction(abortContext.controller);
+    let acquiredSession;
+    try {
+      const resolvedSession = await this.resolveSession();
+      if (!resolvedSession) {
+        return await raceWithAbort(fn, abortContext.signal);
+      }
+      acquiredSession = resolvedSession;
+      return await this.sessions.run(resolvedSession, () => executeSessionTransaction(resolvedSession, () => this.sessions.run(resolvedSession, () => raceWithAbort(fn, abortContext.signal))));
+    } finally {
+      abortContext.cleanup();
+      try {
+        await acquiredSession?.endSession();
+      } finally {
+        this.untrackActiveRequestTransaction(active);
+      }
+    }
+  }
+  trackActiveRequestTransaction(controller) {
+    return trackActiveRequestTransaction(this.activeRequestTransactions, controller);
+  }
+  untrackActiveRequestTransaction(handle) {
+    untrackActiveRequestTransaction(this.activeRequestTransactions, handle);
+  }
+  async resolveSession() {
+    if (typeof this.connection.startSession !== 'function') {
+      if (this.connectionOptions.strictTransactions) {
+        throw new Error(TRANSACTIONS_NOT_SUPPORTED_ERROR);
+      }
+      return undefined;
+    }
+    return this.connection.startSession();
+  }
+  static {
+    _initClass();
+  }
+}
+export { _MongooseConnection as MongooseConnection };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './connection.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,iBAAiB,CAAC;AAChC,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 './connection.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,21 @@
+import type { AsyncModuleOptions } from '@fluojs/core';
+import type { Provider } from '@fluojs/di';
+import { type ModuleType } from '@fluojs/runtime';
+import type { MongooseConnectionLike, MongooseModuleOptions } from './types.js';
+/**
+ * Creates Mongoose providers for manual module composition.
+ *
+ * @param options Mongoose module options with a connection handle, optional dispose hook, and strict transaction policy.
+ * @returns Provider definitions equivalent to `MongooseModule.forRoot(...)`.
+ */
+export declare function createMongooseProviders<TConnection extends MongooseConnectionLike>(options: MongooseModuleOptions<TConnection>): Provider[];
+/**
+ * Module entrypoint for wiring a Mongoose connection into the Fluo runtime lifecycle.
+ */
+export declare class MongooseModule {
+    /** Creates a module definition from static Mongoose options. */
+    static forRoot<TConnection extends MongooseConnectionLike>(options: MongooseModuleOptions<TConnection>): ModuleType;
+    /** Creates a module definition from DI-aware async Mongoose options. */
+    static forRootAsync<TConnection extends MongooseConnectionLike>(options: AsyncModuleOptions<MongooseModuleOptions<TConnection>>): 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;AACvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAKhE,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AA4FhF;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,SAAS,sBAAsB,EAChF,OAAO,EAAE,qBAAqB,CAAC,WAAW,CAAC,GAC1C,QAAQ,EAAE,CAOZ;AAwBD;;GAEG;AACH,qBAAa,cAAc;IACzB,gEAAgE;IAChE,MAAM,CAAC,OAAO,CAAC,WAAW,SAAS,sBAAsB,EAAE,OAAO,EAAE,qBAAqB,CAAC,WAAW,CAAC,GAAG,UAAU;IAInH,wEAAwE;IACxE,MAAM,CAAC,YAAY,CAAC,WAAW,SAAS,sBAAsB,EAC5D,OAAO,EAAE,kBAAkB,CAAC,qBAAqB,CAAC,WAAW,CAAC,CAAC,GAC9D,UAAU;CAGd"}

package/dist/module.js

@@ -0,0 +1,97 @@
+import { defineModule } from '@fluojs/runtime';
+import { MongooseConnection } from './connection.js';
+import { MONGOOSE_CONNECTION, MONGOOSE_DISPOSE, MONGOOSE_OPTIONS } from './tokens.js';
+import { MongooseTransactionInterceptor } from './transaction.js';
+const MONGOOSE_NORMALIZED_OPTIONS = Symbol('fluo.mongoose.normalized-options');
+const MONGOOSE_MODULE_EXPORTS = [MongooseConnection, MongooseTransactionInterceptor];
+function normalizeMongooseModuleOptions(options) {
+  return {
+    ...options,
+    strictTransactions: options.strictTransactions ?? false
+  };
+}
+function createRuntimeOptionsProviderValue(strictTransactions) {
+  return {
+    strictTransactions
+  };
+}
+function createMongooseRuntimeProviders(normalizedOptionsProvider) {
+  return [normalizedOptionsProvider, {
+    inject: [MONGOOSE_NORMALIZED_OPTIONS],
+    provide: MONGOOSE_CONNECTION,
+    useFactory: options => options.connection
+  }, {
+    inject: [MONGOOSE_NORMALIZED_OPTIONS],
+    provide: MONGOOSE_DISPOSE,
+    useFactory: options => options.dispose
+  }, {
+    inject: [MONGOOSE_NORMALIZED_OPTIONS],
+    provide: MONGOOSE_OPTIONS,
+    useFactory: options => createRuntimeOptionsProviderValue(options.strictTransactions)
+  }, MongooseConnection, MongooseTransactionInterceptor];
+}
+function createMemoizedMongooseOptionsResolver(options) {
+  let cachedResult;
+  return (...deps) => {
+    if (!cachedResult) {
+      cachedResult = Promise.resolve(options.useFactory(...deps)).then(resolved => normalizeMongooseModuleOptions(resolved));
+    }
+    if (!cachedResult) {
+      throw new Error('Mongoose module options resolver initialization failed.');
+    }
+    return cachedResult;
+  };
+}
+function createMongooseProvidersAsync(options) {
+  const resolveOptions = createMemoizedMongooseOptionsResolver(options);
+  const normalizedOptionsProvider = {
+    inject: options.inject,
+    provide: MONGOOSE_NORMALIZED_OPTIONS,
+    scope: 'singleton',
+    useFactory: async (...deps) => resolveOptions(...deps)
+  };
+  return createMongooseRuntimeProviders(normalizedOptionsProvider);
+}
+
+/**
+ * Creates Mongoose providers for manual module composition.
+ *
+ * @param options Mongoose module options with a connection handle, optional dispose hook, and strict transaction policy.
+ * @returns Provider definitions equivalent to `MongooseModule.forRoot(...)`.
+ */
+export function createMongooseProviders(options) {
+  const resolved = normalizeMongooseModuleOptions(options);
+  return createMongooseRuntimeProviders({
+    provide: MONGOOSE_NORMALIZED_OPTIONS,
+    useValue: resolved
+  });
+}
+function buildMongooseModule(options) {
+  class MongooseRootModuleDefinition {}
+  return defineModule(MongooseRootModuleDefinition, {
+    exports: MONGOOSE_MODULE_EXPORTS,
+    providers: createMongooseProviders(options)
+  });
+}
+function buildMongooseModuleAsync(options) {
+  class MongooseAsyncModuleDefinition {}
+  return defineModule(MongooseAsyncModuleDefinition, {
+    exports: MONGOOSE_MODULE_EXPORTS,
+    providers: createMongooseProvidersAsync(options)
+  });
+}
+
+/**
+ * Module entrypoint for wiring a Mongoose connection into the Fluo runtime lifecycle.
+ */
+export class MongooseModule {
+  /** Creates a module definition from static Mongoose options. */
+  static forRoot(options) {
+    return buildMongooseModule(options);
+  }
+
+  /** Creates a module definition from DI-aware async Mongoose options. */
+  static forRootAsync(options) {
+    return buildMongooseModuleAsync(options);
+  }
+}

package/dist/status.d.ts

@@ -0,0 +1,18 @@
+import type { PersistencePlatformStatusSnapshot } from '@fluojs/runtime';
+type MongoosePlatformLifecycleState = 'ready' | 'shutting-down' | 'stopped';
+type MongoosePlatformStatusSnapshotInput = {
+    activeRequestTransactions: number;
+    hasActiveSession: boolean;
+    lifecycleState: MongoosePlatformLifecycleState;
+    strictTransactions: boolean;
+    supportsStartSession: boolean;
+};
+/**
+ * Maps Mongoose lifecycle and session capability diagnostics into the shared persistence snapshot shape.
+ *
+ * @param input Current Mongoose ownership, readiness, and health inputs.
+ * @returns Platform-facing persistence status data for diagnostics surfaces.
+ */
+export declare function createMongoosePlatformStatusSnapshot(input: MongoosePlatformStatusSnapshotInput): 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,8BAA8B,GAAG,OAAO,GAAG,eAAe,GAAG,SAAS,CAAC;AAE5E,KAAK,mCAAmC,GAAG;IACzC,yBAAyB,EAAE,MAAM,CAAC;IAClC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,8BAA8B,CAAC;IAC/C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAqDF;;;;;GAKG;AACH,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,mCAAmC,GACzC,iCAAiC,CAkBnC"}

package/dist/status.js

@@ -0,0 +1,70 @@
+function createReadiness(input) {
+  if (input.lifecycleState === 'shutting-down') {
+    return {
+      critical: true,
+      reason: 'Mongoose integration is shutting down.',
+      status: 'not-ready'
+    };
+  }
+  if (input.lifecycleState === 'stopped') {
+    return {
+      critical: true,
+      reason: 'Mongoose integration is stopped.',
+      status: 'not-ready'
+    };
+  }
+  if (input.strictTransactions && !input.supportsStartSession) {
+    return {
+      critical: true,
+      reason: 'Mongoose strictTransactions is enabled but connection.startSession is unavailable.',
+      status: 'not-ready'
+    };
+  }
+  return {
+    critical: true,
+    status: 'ready'
+  };
+}
+function createHealth(input) {
+  if (input.lifecycleState === 'stopped') {
+    return {
+      reason: 'Mongoose integration has been disposed.',
+      status: 'unhealthy'
+    };
+  }
+  if (input.lifecycleState === 'shutting-down') {
+    return {
+      reason: 'Mongoose integration is draining request transactions during shutdown.',
+      status: 'degraded'
+    };
+  }
+  return {
+    status: 'healthy'
+  };
+}
+
+/**
+ * Maps Mongoose lifecycle and session capability diagnostics into the shared persistence snapshot shape.
+ *
+ * @param input Current Mongoose ownership, readiness, and health inputs.
+ * @returns Platform-facing persistence status data for diagnostics surfaces.
+ */
+export function createMongoosePlatformStatusSnapshot(input) {
+  return {
+    details: {
+      activeRequestTransactions: input.activeRequestTransactions,
+      hasActiveSession: input.hasActiveSession,
+      lifecycleState: input.lifecycleState,
+      sessionStrategy: input.supportsStartSession ? 'explicit-session' : 'none',
+      strictTransactions: input.strictTransactions,
+      supportsStartSession: input.supportsStartSession,
+      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 Mongoose connection handle. */
+export declare const MONGOOSE_CONNECTION: unique symbol;
+/** Dependency-injection token for the optional Mongoose shutdown dispose hook. */
+export declare const MONGOOSE_DISPOSE: unique symbol;
+/** Dependency-injection token for normalized Mongoose runtime options. */
+export declare const MONGOOSE_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,yEAAyE;AACzE,eAAO,MAAM,mBAAmB,eAAyC,CAAC;AAC1E,kFAAkF;AAClF,eAAO,MAAM,gBAAgB,eAAsC,CAAC;AACpE,0EAA0E;AAC1E,eAAO,MAAM,gBAAgB,eAAsC,CAAC"}

package/dist/tokens.js

@@ -0,0 +1,6 @@
+/** Dependency-injection token for the raw Mongoose connection handle. */
+export const MONGOOSE_CONNECTION = Symbol.for('fluo.mongoose.connection');
+/** Dependency-injection token for the optional Mongoose shutdown dispose hook. */
+export const MONGOOSE_DISPOSE = Symbol.for('fluo.mongoose.dispose');
+/** Dependency-injection token for normalized Mongoose runtime options. */
+export const MONGOOSE_OPTIONS = Symbol.for('fluo.mongoose.options');

package/dist/transaction.d.ts

@@ -0,0 +1,25 @@
+import type { Interceptor, InterceptorContext } from '@fluojs/http';
+import { MongooseConnection } from './connection.js';
+import type { MongooseConnectionLike } from './types.js';
+/**
+ * HTTP interceptor that wraps each request in a Mongoose request transaction boundary.
+ *
+ * @remarks
+ * Pair this with repository/service code that reads `MongooseConnection.current()` and `currentSession()` so downstream
+ * calls share the same request-scoped session.
+ */
+export declare class MongooseTransactionInterceptor implements Interceptor {
+    private readonly connection;
+    constructor(connection: MongooseConnection<MongooseConnectionLike>);
+    /**
+     * Runs the downstream handler inside a Mongoose 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,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEzD;;;;;;GAMG;AACH,qBACa,8BAA+B,YAAW,WAAW;IACpD,OAAO,CAAC,QAAQ,CAAC,UAAU;gBAAV,UAAU,EAAE,kBAAkB,CAAC,sBAAsB,CAAC;IAEnF;;;;;;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 { MongooseConnection } from './connection.js';
+let _MongooseTransactionI;
+/**
+ * HTTP interceptor that wraps each request in a Mongoose request transaction boundary.
+ *
+ * @remarks
+ * Pair this with repository/service code that reads `MongooseConnection.current()` and `currentSession()` so downstream
+ * calls share the same request-scoped session.
+ */
+class MongooseTransactionInterceptor {
+  static {
+    [_MongooseTransactionI, _initClass] = _applyDecs(this, [Inject(MongooseConnection)], []).c;
+  }
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Runs the downstream handler inside a Mongoose 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.connection.requestTransaction(async () => next.handle(), context.requestContext.request.signal);
+  }
+  static {
+    _initClass();
+  }
+}
+export { _MongooseTransactionI as MongooseTransactionInterceptor };

package/dist/types.d.ts

@@ -0,0 +1,64 @@
+import type { MaybePromise } from '@fluojs/core';
+/**
+ * Minimal Mongoose connection seam that optionally supports session creation.
+ *
+ * @remarks
+ * Fluo only requires `startSession()` to expose transaction helpers; plain connection usage still works without it.
+ */
+export interface MongooseConnectionLike {
+    startSession?(): Promise<MongooseSessionLike>;
+}
+/**
+ * Session contract used by the Mongoose transaction wrapper.
+ */
+export interface MongooseSessionLike {
+    startTransaction(): MaybePromise<void>;
+    commitTransaction(): MaybePromise<void>;
+    abortTransaction(): MaybePromise<void>;
+    endSession(): MaybePromise<void>;
+}
+/**
+ * Module options for registering a Mongoose connection and optional shutdown disposal hook.
+ *
+ * @typeParam TConnection Root Mongoose connection shape registered in the module.
+ */
+export interface MongooseModuleOptions<TConnection extends MongooseConnectionLike = MongooseConnectionLike> {
+    /** Root Mongoose connection shared outside request/session transaction scopes. */
+    connection: TConnection;
+    /** Optional shutdown hook used to close the connection or surrounding driver resources. */
+    dispose?: (connection: TConnection) => MaybePromise<void>;
+    /**
+     * Throws when transaction helpers are used against a connection that does not implement `startSession()`.
+     *
+     * @remarks
+     * Leave this disabled when `transaction()` / `requestTransaction()` should fall back to direct execution.
+     */
+    strictTransactions?: boolean;
+}
+/**
+ * Public Mongoose wrapper contract exposed through dependency injection.
+ *
+ * @typeParam TConnection Root Mongoose connection shape registered in the module.
+ */
+export interface MongooseHandleProvider<TConnection extends MongooseConnectionLike = MongooseConnectionLike> {
+    /** Returns the root Mongoose connection used for model access and session creation. */
+    current(): TConnection;
+    /** Returns the ambient Mongoose session for the current async context, when one exists. */
+    currentSession(): MongooseSessionLike | undefined;
+    /**
+     * Opens a Mongoose session transaction boundary around `fn`.
+     *
+     * @param fn Callback executed within the transaction scope.
+     * @returns The callback result after the session transaction finishes or the direct-execution fallback completes.
+     */
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * 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.
+     * @returns The callback result after the request transaction finishes or the direct-execution fallback completes.
+     */
+    requestTransaction<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+}
+//# 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;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,YAAY,CAAC,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACvC,iBAAiB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACxC,gBAAgB,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IACvC,UAAU,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB;IACxG,kFAAkF;IAClF,UAAU,EAAE,WAAW,CAAC;IACxB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,WAAW,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC;IAC1D;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB,CAAC,WAAW,SAAS,sBAAsB,GAAG,sBAAsB;IACzG,uFAAuF;IACvF,OAAO,IAAI,WAAW,CAAC;IACvB,2FAA2F;IAC3F,cAAc,IAAI,mBAAmB,GAAG,SAAS,CAAC;IAClD;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/E"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@fluojs/mongoose",
+  "description": "Mongoose integration for Fluo with session-aware transaction context and lifecycle management.",
+  "keywords": [
+    "fluo",
+    "mongoose",
+    "mongodb",
+    "database",
+    "transaction",
+    "odm"
+  ],
+  "version": "1.0.0-beta.1",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fluojs/fluo.git",
+    "directory": "packages/mongoose"
+  },
+  "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/di": "^1.0.0-beta.1",
+    "@fluojs/runtime": "^1.0.0-beta.1",
+    "@fluojs/http": "^1.0.0-beta.1"
+  },
+  "peerDependencies": {
+    "mongoose": ">=7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "mongoose": {
+      "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"
+  }
+}