@fluojs/prisma 1.0.2 → 1.1.1

package/dist/service.js

@@ -4,13 +4,28 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 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 { createAbortError, createRequestAbortContext, raceWithAbort, trackActiveRequestTransaction, untrackActiveRequestTransaction } from '@fluojs/runtime';
 import { Inject } from '@fluojs/core';
+import { createAbortError, createRequestAbortContext, raceWithAbort, trackActiveRequestTransaction, untrackActiveRequestTransaction } from '@fluojs/runtime';
+import { markPrismaServiceHandle } from './prisma-service-brand.js';
 import { createPrismaPlatformStatusSnapshot } from './status.js';
 import { PRISMA_CLIENT, PRISMA_OPTIONS } from './tokens.js';
 const NESTED_TRANSACTION_OPTIONS_NOT_SUPPORTED_ERROR = 'Nested Prisma transaction options are not supported because the active transaction context is reused.';
 const REQUEST_TRANSACTION_UNAVAILABLE_ERROR = 'Prisma request transactions are not available during shutdown.';
+const TRANSACTION_BOUNDARY_UNAVAILABLE_ERROR = 'Prisma transaction boundaries are not available during shutdown.';
 const TRANSACTION_CONTEXT_UNAVAILABLE_ERROR = 'Prisma transaction context requires AsyncLocalStorage support from the host runtime.';
+function createCurrentClientPrismaFacade(target) {
+  markPrismaServiceHandle(target);
+  return markPrismaServiceHandle(new Proxy(target, {
+    get(service, prop, receiver) {
+      if (prop in service) {
+        return Reflect.get(service, prop, receiver);
+      }
+      const currentClient = service.current();
+      const value = Reflect.get(currentClient, prop, currentClient);
+      return typeof value === 'function' ? value.bind(currentClient) : value;
+    }
+  }));
+}
 class AsyncLocalStorageTransactionContextStore {
   kind = 'als';
   storage;
@@ -37,7 +52,11 @@ function resolveAsyncLocalStorageConstructor(host = globalThis) {
   if (typeof host.AsyncLocalStorage === 'function') {
     return host.AsyncLocalStorage;
   }
-  return host.process?.getBuiltinModule?.('node:async_hooks').AsyncLocalStorage;
+  try {
+    return host.process?.getBuiltinModule?.('node:async_hooks')?.AsyncLocalStorage;
+  } catch {
+    return undefined;
+  }
 }
 function createTransactionContextStore() {
   const AsyncLocalStorage = resolveAsyncLocalStorageConstructor();
@@ -61,6 +80,7 @@ class PrismaService {
   }
   transactions = createTransactionContextStore();
   activeRequestTransactions = new Set();
+  activeTransactionBoundaries = new Set();
   transactionAbortSignalSupport = 'unknown';
   lifecycleState = 'created';
   constructor(client, serviceOptions = {
@@ -68,6 +88,41 @@ class PrismaService {
   }) {
     this.client = client;
     this.serviceOptions = serviceOptions;
+    markPrismaServiceHandle(this);
+    this.installCurrentClientFacade();
+  }
+
+  /**
+   * Creates the low-level DI facade that forwards unknown Prisma API properties to the ambient `current()` client.
+   *
+   * @remarks
+   * This compatibility helper is used by `PrismaModule` provider wiring. Application code should prefer
+   * `PrismaModule.forRoot(...)` or `PrismaModule.forRootAsync(...)`, then type injected repository handles as
+   * `PrismaServiceFacade<TClient>` when direct generated Prisma delegates are needed.
+   *
+   * @param client Root Prisma client registered in the module.
+   * @param serviceOptions Runtime transaction options consumed by the Fluo wrapper.
+   * @returns A transaction-aware facade that exposes wrapper methods plus the root Prisma client surface.
+   */
+  static createFacade(client, serviceOptions = {
+    strictTransactions: false
+  }) {
+    return createCurrentClientPrismaFacade(new _PrismaService(client, serviceOptions));
+  }
+  installCurrentClientFacade() {
+    for (const prop of Reflect.ownKeys(this.client)) {
+      if (prop in this) {
+        continue;
+      }
+      Object.defineProperty(this, prop, {
+        configurable: true,
+        get: () => {
+          const current = this.current();
+          const value = Reflect.get(current, prop);
+          return typeof value === 'function' ? value.bind(current) : value;
+        }
+      });
+    }
   }
 
   /**
@@ -90,23 +145,29 @@ class PrismaService {
       }
       return fn();
     }
-    if (typeof this.client.$transaction !== 'function') {
-      if (this.serviceOptions.strictTransactions) {
-        throw new Error('Transaction not supported: Prisma client does not implement $transaction.');
-      }
-      return fn();
-    }
-    this.assertTransactionContextAvailable();
-    const deferredRequestTransactionHandles = new Set();
+    this.assertTransactionBoundariesAvailable();
+    const activeTransaction = this.trackActiveTransactionBoundary();
     try {
-      return await run(transactionClient => this.transactions.run({
-        client: transactionClient,
-        deferredRequestTransactionHandles
-      }, fn), options);
-    } finally {
-      for (const handle of deferredRequestTransactionHandles) {
-        this.untrackActiveRequestTransaction(handle);
+      if (typeof this.client.$transaction !== 'function') {
+        if (this.serviceOptions.strictTransactions) {
+          throw new Error('Transaction not supported: Prisma client does not implement $transaction.');
+        }
+        return await fn();
+      }
+      this.assertTransactionContextAvailable();
+      const deferredRequestTransactionHandles = new Set();
+      try {
+        return await run(transactionClient => this.transactions.run({
+          client: transactionClient,
+          deferredRequestTransactionHandles
+        }, fn), options);
+      } finally {
+        for (const handle of deferredRequestTransactionHandles) {
+          this.untrackActiveRequestTransaction(handle);
+        }
       }
+    } finally {
+      this.untrackActiveTransactionBoundary(activeTransaction);
     }
   }
   async onModuleInit() {
@@ -121,6 +182,7 @@ class PrismaService {
       transaction.abort(new Error('Application shutdown interrupted an open request transaction.'));
     }
     await Promise.allSettled(Array.from(this.activeRequestTransactions, transaction => transaction.settled));
+    await Promise.allSettled(Array.from(this.activeTransactionBoundaries, transaction => transaction.settled));
     if (typeof this.client.$disconnect === 'function') {
       await this.client.$disconnect();
     }
@@ -249,6 +311,11 @@ class PrismaService {
       throw new Error(REQUEST_TRANSACTION_UNAVAILABLE_ERROR);
     }
   }
+  assertTransactionBoundariesAvailable() {
+    if (this.lifecycleState === 'shutting-down' || this.lifecycleState === 'stopped') {
+      throw new Error(TRANSACTION_BOUNDARY_UNAVAILABLE_ERROR);
+    }
+  }
   assertTransactionContextAvailable() {
     if (this.transactions.kind === 'unavailable') {
       throw new Error(TRANSACTION_CONTEXT_UNAVAILABLE_ERROR);
@@ -322,8 +389,38 @@ class PrismaService {
   untrackActiveRequestTransaction(handle) {
     untrackActiveRequestTransaction(this.activeRequestTransactions, handle);
   }
+  trackActiveTransactionBoundary() {
+    let settle;
+    const active = {
+      settled: new Promise(resolve => {
+        settle = resolve;
+      })
+    };
+    this.activeTransactionBoundaries.add(active);
+    return {
+      active,
+      settle
+    };
+  }
+  untrackActiveTransactionBoundary(handle) {
+    this.activeTransactionBoundaries.delete(handle.active);
+    handle.settle();
+  }
   static {
     _initClass();
   }
 }
+
+/**
+ * Injection-facing Prisma facade type that combines the Fluo wrapper methods with the registered Prisma client surface.
+ *
+ * @remarks
+ * `PrismaModule` resolves `PrismaService` to a facade that forwards unknown properties to `current()`. Use this type in
+ * repositories that call generated Prisma delegates directly, and use `PrismaService<TClient>` when only wrapper methods
+ * (`current()`, `transaction(...)`, `requestTransaction(...)`, and status snapshots) are needed.
+ *
+ * @typeParam TClient Root Prisma client shape registered in the module.
+ * @typeParam TTransactionClient Transaction-scoped client resolved inside `$transaction(...)` callbacks.
+ * @typeParam TTransactionOptions Options forwarded to Prisma interactive transactions.
+ */
 export { _PrismaService as PrismaService };

package/dist/transaction-decorator-contract.notes.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TC39 standard method decorator — 2023-11 (Babel @babel/plugin-proposal-decorators)
+ * NO reflect-metadata. NO experimentalDecorators.
+ *
+ * Factory signature:
+ *   Transaction(accessor?) returns (value, context: ClassMethodDecoratorContext) => Function
+ *
+ * Default:    @Transaction()                         — uses `this` as the service
+ * Explicit:   @Transaction((self) => self.analytics) — uses returned service property
+ *
+ * Nested reuse: if active context exists, reuses it (no new transaction opened)
+ * Nested options: if active context exists AND options passed, THROWS
+ */
+export type TransactionAccessor<THost, TService> = (self: THost) => TService;
+/**
+ * Standard method decorator factory signature for Prisma service transaction boundaries.
+ */
+export type TransactionDecorator = <TService>(accessor?: TransactionAccessor<unknown, TService>) => (value: Function, context: ClassMethodDecoratorContext) => Function;
+//# sourceMappingURL=transaction-decorator-contract.notes.d.ts.map

package/dist/transaction-decorator-contract.notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-decorator-contract.notes.d.ts","sourceRoot":"","sources":["../src/transaction-decorator-contract.notes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,mBAAmB,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,QAAQ,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,QAAQ,EAC1C,QAAQ,CAAC,EAAE,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,KAC9C,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,QAAQ,CAAC"}

package/dist/transaction-decorator-contract.notes.js

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

package/dist/transaction.d.ts

@@ -1,25 +1,49 @@
-import type { Interceptor, InterceptorContext } from '@fluojs/http';
+import type { CallHandler, Interceptor, InterceptorContext } from '@fluojs/http';
 import { PrismaService } from './service.js';
 import type { PrismaClientLike } from './types.js';
+type TransactionalPrismaService<TOptions = unknown> = {
+    createPlatformStatusSnapshot(): unknown;
+    current(): unknown;
+    transaction<T>(fn: () => Promise<T>, options?: TOptions): Promise<T>;
+};
+type TransactionAccessor<THost, TOptions> = (self: THost) => TransactionalPrismaService<TOptions>;
+type TransactionMethod<THost, TArgs extends unknown[], TResult> = (this: THost, ...args: TArgs) => Promise<TResult>;
 /**
- * HTTP interceptor that wraps a request handler in `PrismaService.requestTransaction(...)`.
+ * Wraps a service method in a `PrismaService.transaction(...)` boundary.
  *
  * @remarks
- * Pair this with repository/service code that reads `PrismaService.current()` so downstream calls share the same
- * request-scoped transaction client.
+ * This is a TC39 standard method decorator (2023-11) and does not use legacy decorator metadata or `reflect-metadata`.
+ * `@Transaction()` resolves a Prisma service from the decorated instance, while
+ * `@Transaction((self) => self.prisma)` selects an explicit service for named or multi-client registrations.
+ * Calls made while a transaction context is already active reuse the existing Prisma transaction through `PrismaService`.
+ * Passing Prisma transaction options to a nested call is rejected by `PrismaService.transaction(...)` so option intent is not
+ * silently ignored.
+ *
+ * @param input Optional service accessor or Prisma interactive transaction options.
+ * @returns A standard method decorator that runs the original method inside a Prisma transaction boundary.
+ */
+export declare function Transaction<THost, TOptions = unknown>(input?: TransactionAccessor<THost, TOptions> | TOptions): <TArgs extends unknown[], TResult>(value: TransactionMethod<THost, TArgs, TResult>, context: ClassMethodDecoratorContext<THost, TransactionMethod<THost, TArgs, TResult>>) => TransactionMethod<THost, TArgs, TResult>;
+/**
+ * Compatibility HTTP interceptor that opens a Prisma request transaction around a routed handler.
+ *
+ * @remarks
+ * This deprecated 1.x bridge forwards the request `AbortSignal` to `PrismaService.requestTransaction(...)` and is
+ * registered only by the unnamed `PrismaModule` entrypoint. Prefer service-layer `@Transaction()` or an explicit
+ * request boundary for new code.
+ *
+ * @deprecated Prefer service-layer `@Transaction()` or explicit `PrismaService.requestTransaction(...)`.
  */
 export declare class PrismaTransactionInterceptor implements Interceptor {
     private readonly prisma;
     constructor(prisma: PrismaService<PrismaClientLike>);
     /**
-     * Runs the downstream handler inside a Prisma request transaction boundary.
+     * Runs the downstream handler inside the compatibility request transaction.
      *
-     * @param context Interceptor context that supplies the request abort signal.
+     * @param context Interceptor context containing the request cancellation signal.
      * @param next Downstream handler chain.
-     * @returns The downstream handler result after the request transaction settles.
+     * @returns The downstream result after the request transaction settles.
      */
-    intercept(context: InterceptorContext, next: {
-        handle(): Promise<unknown>;
-    }): Promise<unknown>;
+    intercept(context: InterceptorContext, next: CallHandler): Promise<unknown>;
 }
+export {};
 //# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEpE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;GAMG;AACH,qBACa,4BAA6B,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa,CAAC,gBAAgB,CAAC;IAEpE;;;;;;OAMG;IACG,SAAS,CAAC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE;QAAE,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;CAGrG"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAGjF,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,KAAK,0BAA0B,CAAC,QAAQ,GAAG,OAAO,IAAI;IACpD,4BAA4B,IAAI,OAAO,CAAC;IACxC,OAAO,IAAI,OAAO,CAAC;IACnB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACtE,CAAC;AAEF,KAAK,mBAAmB,CAAC,KAAK,EAAE,QAAQ,IAAI,CAAC,IAAI,EAAE,KAAK,KAAK,0BAA0B,CAAC,QAAQ,CAAC,CAAC;AAElG,KAAK,iBAAiB,CAAC,KAAK,EAAE,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,IAAI,CAChE,IAAI,EAAE,KAAK,EACX,GAAG,IAAI,EAAE,KAAK,KACX,OAAO,CAAC,OAAO,CAAC,CAAC;AAuEtB;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,EACnD,KAAK,CAAC,EAAE,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,GACtD,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EAClC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAC/C,OAAO,EAAE,2BAA2B,CAAC,KAAK,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,KAClF,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAiB5C;AAED;;;;;;;;;GASG;AACH,qBACa,4BAA6B,YAAW,WAAW;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa,CAAC,gBAAgB,CAAC;IAEpE;;;;;;OAMG;IACG,SAAS,CAAC,OAAO,EAAE,kBAAkB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;CAGlF"}

package/dist/transaction.js

@@ -5,15 +5,93 @@ 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 { Inject } from '@fluojs/core';
+import { isPrismaServiceHandle } from './prisma-service-brand.js';
 import { PrismaService } from './service.js';
-let _PrismaTransactionInt;
+function isPrismaServiceLike(value) {
+  return typeof value === 'object' && value !== null && isPrismaServiceHandle(value) && 'createPlatformStatusSnapshot' in value && typeof value.createPlatformStatusSnapshot === 'function' && 'current' in value && typeof value.current === 'function' && 'transaction' in value && typeof value.transaction === 'function';
+}
+function readProperty(value, property) {
+  if (typeof value !== 'object' && typeof value !== 'function' || value === null) {
+    return undefined;
+  }
+  return Reflect.get(value, property);
+}
+function addPrismaServiceCandidate(candidates, value) {
+  if (!isPrismaServiceLike(value) || candidates.includes(value)) {
+    return;
+  }
+  candidates.push(value);
+}
+function resolveDefaultPrismaService(self) {
+  const candidates = [];
+  const directPrisma = readProperty(self, 'prisma');
+  addPrismaServiceCandidate(candidates, directPrisma);
+  addPrismaServiceCandidate(candidates, self);
+  for (const value of Object.values(Object(self))) {
+    addPrismaServiceCandidate(candidates, value);
+    const nestedPrisma = readProperty(value, 'prisma');
+    addPrismaServiceCandidate(candidates, nestedPrisma);
+  }
+  if (candidates.length === 1) {
+    return candidates[0];
+  }
+  if (candidates.length > 1) {
+    throw new Error('Ambiguous PrismaService resolution for @Transaction(). Provide an explicit accessor function.');
+  }
+  throw new Error('Unable to resolve PrismaService for @Transaction(). Provide an accessor function.');
+}
+function resolveTransactionInput(input) {
+  if (typeof input === 'function') {
+    return {
+      accessor: input
+    };
+  }
+  return {
+    options: input
+  };
+}
+
 /**
- * HTTP interceptor that wraps a request handler in `PrismaService.requestTransaction(...)`.
+ * Wraps a service method in a `PrismaService.transaction(...)` boundary.
  *
  * @remarks
- * Pair this with repository/service code that reads `PrismaService.current()` so downstream calls share the same
- * request-scoped transaction client.
+ * This is a TC39 standard method decorator (2023-11) and does not use legacy decorator metadata or `reflect-metadata`.
+ * `@Transaction()` resolves a Prisma service from the decorated instance, while
+ * `@Transaction((self) => self.prisma)` selects an explicit service for named or multi-client registrations.
+ * Calls made while a transaction context is already active reuse the existing Prisma transaction through `PrismaService`.
+ * Passing Prisma transaction options to a nested call is rejected by `PrismaService.transaction(...)` so option intent is not
+ * silently ignored.
+ *
+ * @param input Optional service accessor or Prisma interactive transaction options.
+ * @returns A standard method decorator that runs the original method inside a Prisma transaction boundary.
  */
+export function Transaction(input) {
+  const {
+    accessor,
+    options
+  } = resolveTransactionInput(input);
+  return function transactionDecorator(value, context) {
+    if (context.kind !== 'method') {
+      throw new Error('@Transaction() can only decorate methods.');
+    }
+    return async function wrappedTransactionMethod(...args) {
+      const prisma = accessor?.(this) ?? resolveDefaultPrismaService(this);
+      return prisma.transaction(() => value.apply(this, args), options);
+    };
+  };
+}
+
+/**
+ * Compatibility HTTP interceptor that opens a Prisma request transaction around a routed handler.
+ *
+ * @remarks
+ * This deprecated 1.x bridge forwards the request `AbortSignal` to `PrismaService.requestTransaction(...)` and is
+ * registered only by the unnamed `PrismaModule` entrypoint. Prefer service-layer `@Transaction()` or an explicit
+ * request boundary for new code.
+ *
+ * @deprecated Prefer service-layer `@Transaction()` or explicit `PrismaService.requestTransaction(...)`.
+ */
+let _PrismaTransactionInt;
 class PrismaTransactionInterceptor {
   static {
     [_PrismaTransactionInt, _initClass] = _applyDecs(this, [Inject(PrismaService)], []).c;
@@ -23,14 +101,14 @@ class PrismaTransactionInterceptor {
   }
 
   /**
-   * Runs the downstream handler inside a Prisma request transaction boundary.
+   * Runs the downstream handler inside the compatibility request transaction.
    *
-   * @param context Interceptor context that supplies the request abort signal.
+   * @param context Interceptor context containing the request cancellation signal.
    * @param next Downstream handler chain.
-   * @returns The downstream handler result after the request transaction settles.
+   * @returns The downstream result after the request transaction settles.
    */
   async intercept(context, next) {
-    return this.prisma.requestTransaction(async () => next.handle(), context.requestContext.request.signal);
+    return this.prisma.requestTransaction(() => next.handle(), context.requestContext.request.signal);
   }
   static {
     _initClass();

package/package.json

@@ -9,7 +9,7 @@
     "transaction",
     "als"
   ],
-  "version": "1.0.2",
+  "version": "1.1.1",
   "private": false,
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "dist"
   ],
   "dependencies": {
-    "@fluojs/core": "^1.0.3",
-    "@fluojs/http": "^1.1.0",
-    "@fluojs/di": "^1.0.3",
-    "@fluojs/runtime": "^1.1.2"
+    "@fluojs/core": "^1.1.0",
+    "@fluojs/http": "^2.0.1",
+    "@fluojs/di": "^2.0.0",
+    "@fluojs/runtime": "^2.0.1"
   },
   "peerDependencies": {
     "@prisma/client": ">=5.0.0"
@@ -51,7 +51,7 @@
   },
   "devDependencies": {
     "vitest": "^3.2.4",
-    "@fluojs/validation": "^1.0.5"
+    "@fluojs/validation": "^1.0.6"
   },
   "scripts": {
     "prebuild": "node ../../tooling/scripts/clean-dist.mjs",