@gravito/core 3.0.0 → 3.0.1

package/dist/hooks/types.d.ts

@@ -1,6 +1,8 @@
 import type { CircuitBreakerOptions } from '../events/CircuitBreaker';
 import type { EventBackend } from '../events/EventBackend';
+import type { MessageQueueBridge } from '../events/MessageQueueBridge';
 import type { EventQueueConfig } from '../events/EventPriorityQueue';
+import type { AggregationConfig } from '../events/aggregation/types';
 /**
  * Callback function for filters (transforms values).
  * @public
@@ -87,8 +89,10 @@ export interface HookManagerConfig {
     /**
      * Database connection for persistent DLQ (optional).
      * If provided, failed events after max retries will be persisted to database.
+     * Typed as `unknown` since core does not depend on @gravito/atlas or any specific DB type.
+     * The consuming code (DeadLetterQueueManager) accepts and narrows this to its internal type.
      */
-    db?: any;
+    db?: unknown;
     /**
      * Enable persistent DLQ for failed events (requires db).
      * @default false
@@ -98,10 +102,10 @@ export interface HookManagerConfig {
      * Message Queue Bridge for distributed event processing via Bull Queue.
      * When provided, enables dispatchQueued() method for routing events to Redis-backed queue.
      */
-    messageQueueBridge?: any;
+    messageQueueBridge?: MessageQueueBridge;
     /**
      * Event aggregation configuration (FS-102).
      * Enables deduplication and micro-batching for improved throughput.
      */
-    aggregation?: any;
+    aggregation?: AggregationConfig;
 }

package/dist/http/types.d.ts

@@ -320,7 +320,7 @@ export interface GravitoContext<V extends GravitoVariables = GravitoVariables> {
      * URL generator helper.
      * Generates a URL for a named route.
      */
-    route: (name: string, params?: Record<string, any>, query?: Record<string, any>) => string;
+    route: (name: string, params?: Record<string, string | number>, query?: Record<string, string | number | boolean | null | undefined>) => string;
     /**
      * Access the native context object from the underlying HTTP engine.
      *
@@ -338,7 +338,7 @@ export interface GravitoContext<V extends GravitoVariables = GravitoVariables> {
      * Access the RequestScopeManager for this request
      * Services resolved through this manager are scoped to the HTTP request lifetime.
      */
-    requestScope(): any;
+    requestScope(): unknown;
     /**
      * Resolve or create a request-scoped service
      *

package/dist/index.browser.d.ts

@@ -23,12 +23,12 @@ export { EventManager } from './EventManager';
 export * from './events';
 export { HookManager, type HookManagerConfig } from './HookManager';
 export { HealthProvider } from './health/HealthProvider';
-export { Arr, abort, abortIf, abortUnless, app, blank, config, DumpDieError, dd, dump, env, filled, hasApp, logger, router, Str, setApp, tap, throwIf, throwUnless, value, } from './helpers';
-export * from './helpers/data';
-export * from './helpers/errors';
-export * from './helpers/response';
+export { Arr, abort, abortIf, abortUnless, app, blank, config, DumpDieError, dd, dump, env, filled, hasApp, logger, router, Str, tap, throwIf, throwUnless, value, } from './helpers';
+export { type DataPath, dataGet, dataHas, dataSet, type PathSegment } from './helpers/data';
+export { createErrorBag, type ErrorBag, errors, old } from './helpers/errors';
+export { type ApiFailure, type ApiSuccess, fail, jsonFail, jsonSuccess, ok, } from './helpers/response';
 export { CookieJar, type CookieOptions } from './http/CookieJar';
 export { deleteCookie, getCookie, setCookie } from './http/cookie';
 export { ServiceProvider } from './ServiceProvider';
 export * from './runtime/index.browser';
-export declare function defineConfig(config: any): any;
+export declare function defineConfig<T extends Record<string, unknown>>(config: T): T;

package/dist/index.browser.js

@@ -149,7 +149,7 @@ var randomBytes = randomBytesFn;
 // package.json
 var package_default = {
   name: "@gravito/core",
-  version: "3.0.0",
+  version: "3.0.1",
   description: "",
   module: "./dist/index.js",
   main: "./dist/index.js",
@@ -158,9 +158,9 @@ var package_default = {
   types: "./dist/index.d.ts",
   exports: {
     ".": {
+      types: "./dist/index.d.ts",
       browser: "./dist/index.browser.js",
       bun: "./dist/index.js",
-      types: "./dist/index.d.ts",
       default: "./dist/index.js"
     },
     "./compat": {
@@ -206,7 +206,8 @@ var package_default = {
     typecheck: "bun tsc -p tsconfig.json --noEmit --skipLibCheck",
     prepublishOnly: "bun run typecheck && bun run test && bun run build",
     "test:unit": "bun test $(find tests -name '*.test.ts' ! -name '*.integration.test.ts' 2>/dev/null | tr '\\n' ' ') --timeout=10000",
-    "test:integration": "test $(find tests -name '*.integration.test.ts' 2>/dev/null | wc -l) -gt 0 && find tests -name '*.integration.test.ts' -print0 | xargs -0 bun test --timeout=10000 || echo 'No integration tests found'"
+    "test:integration": "test $(find tests -name '*.integration.test.ts' 2>/dev/null | wc -l) -gt 0 && find tests -name '*.integration.test.ts' -print0 | xargs -0 bun test --timeout=10000 || echo 'No integration tests found'",
+    publint: "publint"
   },
   keywords: [],
   author: "Carl Lee <carllee0520@gmail.com>",
@@ -253,6 +254,7 @@ class RadixNode {
   paramChild = null;
   wildcardChild = null;
   handlers = new Map;
+  options = new Map;
   paramName = null;
   regex = null;
   constructor(segment = "", type = 0 /* STATIC */) {
@@ -266,13 +268,15 @@ class RadixNode {
       children: Array.from(this.children.entries()).map(([k, v]) => [k, v.toJSON()]),
       paramChild: this.paramChild?.toJSON() || null,
       wildcardChild: this.wildcardChild?.toJSON() || null,
+      handlers: Array.from(this.handlers.entries()),
+      options: Array.from(this.options.entries()),
       paramName: this.paramName,
       regex: this.regex ? this.regex.source : null
     };
   }
   static fromJSON(json) {
     const node = new RadixNode(json.segment, json.type);
-    node.paramName = json.paramName;
+    node.paramName = json.paramName ?? null;
     if (json.regex) {
       node.regex = new RegExp(json.regex);
     }
@@ -287,6 +291,16 @@ class RadixNode {
     if (json.wildcardChild) {
       node.wildcardChild = RadixNode.fromJSON(json.wildcardChild);
     }
+    if (json.handlers) {
+      for (const [method, handlers] of json.handlers) {
+        node.handlers.set(method, handlers);
+      }
+    }
+    if (json.options) {
+      for (const [method, options2] of json.options) {
+        node.options.set(method, options2);
+      }
+    }
     return node;
   }
 }
@@ -322,7 +336,7 @@ class RadixRouter {
   where(param, regex) {
     this.globalConstraints.set(param, regex);
   }
-  add(method, path2, handlers) {
+  add(method, path2, handlers, options2) {
     let node = this.root;
     const segments = this.splitPath(path2);
     for (let i = 0;i < segments.length; i++) {
@@ -352,7 +366,11 @@ class RadixRouter {
         node = node.children.get(segment);
       }
     }
-    node.handlers.set(method.toLowerCase(), handlers);
+    const normalizedMethod = method.toLowerCase();
+    node.handlers.set(normalizedMethod, handlers);
+    if (options2) {
+      node.options.set(normalizedMethod, options2);
+    }
     this.routeCache.clear();
   }
   match(method, path2) {
@@ -360,7 +378,7 @@ class RadixRouter {
     if (path2 === "/" || path2 === "") {
       const handlers = this.root.handlers.get(normalizedMethod);
       if (handlers) {
-        return { handlers, params: {} };
+        return { handlers, params: {}, options: this.root.options.get(normalizedMethod) };
       }
       return null;
     }
@@ -377,11 +395,13 @@ class RadixRouter {
   matchRecursive(node, segments, depth, params, method) {
     if (depth >= segments.length) {
       let handlers = node.handlers.get(method);
+      let options2 = node.options.get(method);
       if (!handlers) {
         handlers = node.handlers.get("all");
+        options2 = node.options.get("all");
       }
       if (handlers) {
-        return { handlers, params };
+        return { handlers, params, options: options2 };
       }
       return null;
     }
@@ -408,11 +428,13 @@ class RadixRouter {
     }
     if (node.wildcardChild) {
       let handlers = node.wildcardChild.handlers.get(method);
+      let options2 = node.wildcardChild.options.get(method);
       if (!handlers) {
         handlers = node.wildcardChild.handlers.get("all");
+        options2 = node.wildcardChild.options.get("all");
       }
       if (handlers) {
-        return { handlers, params };
+        return { handlers, params, options: options2 };
       }
     }
     return null;
@@ -894,7 +916,7 @@ class RequestScopeManager {
     let servicesCleaned = 0;
     for (const [, instance] of this.scoped) {
       if (instance && typeof instance === "object" && "cleanup" in instance) {
-        const fn = instance.cleanup;
+        const fn = instance["cleanup"];
         if (typeof fn === "function") {
           try {
             await fn.call(instance);
@@ -2548,7 +2570,8 @@ function createNodeAdapter() {
         },
         resourceUsage: async () => {
           try {
-            const usage = child.resourceUsage?.();
+            const childWithUsage = child;
+            const usage = childWithUsage.resourceUsage?.();
             if (!usage) {
               return;
             }
@@ -2757,6 +2780,78 @@ function createUnknownAdapter() {
     }
   };
 }
+// src/runtime/NativeOrbitDetector.ts
+function probeCryptoHasher(CryptoHasherCtor, algo) {
+  try {
+    const ctor = CryptoHasherCtor;
+    new ctor(algo).update("").digest("hex");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+class NativeOrbitDetector {
+  static cached = null;
+  static detectBunCapabilities() {
+    if (this.cached !== null) {
+      return this.cached;
+    }
+    const kind2 = getRuntimeKind();
+    const B2 = globalThis.Bun;
+    if (kind2 !== "bun" || !B2) {
+      this.cached = Object.freeze({
+        runtime: kind2,
+        bunVersion: null,
+        password: Object.freeze({ available: false, argon2id: false, bcrypt: false }),
+        cryptoHasher: Object.freeze({
+          available: false,
+          sha256: false,
+          sha512: false,
+          blake2b: false
+        }),
+        glob: false
+      });
+      return this.cached;
+    }
+    const hasPassword = typeof B2.password?.hash === "function" && typeof B2.password?.verify === "function";
+    const passwordFeatures = Object.freeze({
+      available: hasPassword,
+      argon2id: hasPassword,
+      bcrypt: hasPassword
+    });
+    const HasherCtor = B2.CryptoHasher;
+    const hasHasher = typeof HasherCtor === "function";
+    const sha256 = hasHasher ? probeCryptoHasher(HasherCtor, "sha256") : false;
+    const sha512 = hasHasher ? probeCryptoHasher(HasherCtor, "sha512") : false;
+    const blake2b = hasHasher ? probeCryptoHasher(HasherCtor, "blake2b256") : false;
+    const cryptoHasherFeatures = Object.freeze({
+      available: hasHasher && sha256,
+      sha256,
+      sha512,
+      blake2b
+    });
+    const hasGlob = typeof B2.Glob === "function";
+    this.cached = Object.freeze({
+      runtime: kind2,
+      bunVersion: B2.version ?? null,
+      password: passwordFeatures,
+      cryptoHasher: cryptoHasherFeatures,
+      glob: hasGlob
+    });
+    return this.cached;
+  }
+  static reset() {
+    this.cached = null;
+  }
+}
+function formatCapabilityReport(f) {
+  const passwordPart = f.password.argon2id ? "Bun.password argon2id \u2713" : "Bun.password argon2id \u2717 (fallback: none)";
+  const hasherPart = f.cryptoHasher.available ? "Bun.CryptoHasher \u2713" : "Bun.CryptoHasher \u2717 (fallback: node:crypto)";
+  const globPart = f.glob ? "Bun.Glob \u2713" : "Bun.Glob \u2717 (fallback: node:fs glob)";
+  return `[gravito] native: ${passwordPart}, ${hasherPart}, ${globPart}`;
+}
+
 // src/runtime/archive.ts
 function createBunArchiveAdapter() {
   return {
@@ -2896,6 +2991,9 @@ async function archiveFromDirectory(dirPath, archivePath, options = {}) {
   let entries = {};
   if (kind === "bun") {
     const B = globalThis.Bun;
+    if (!B?.Glob || !B.file) {
+      throw new Error("[RuntimeArchiveAdapter] Bun global not available for directory scanning");
+    }
     const glob = new B.Glob(options.glob ?? "**/*");
     for await (const file of glob.scan(dirPath)) {
       const pathMod = await eval('import("node:path")');
@@ -3509,6 +3607,9 @@ function getPasswordAdapter() {
   };
   return passwordAdapter;
 }
+function resetPasswordAdapter() {
+  passwordAdapter = null;
+}
 async function createSqliteDatabase(path2) {
   const kind2 = getRuntimeKind();
   const B2 = globalThis.Bun;
@@ -3657,6 +3758,15 @@ class CircularDependencyException extends SystemException {
   }
 }
 
+// src/exceptions/ContainerBindingCollisionException.ts
+class ContainerBindingCollisionException extends SystemException {
+  constructor(message, options2 = {}) {
+    super(500, "system.container_binding_collision", { ...options2, message });
+    this.name = "ContainerBindingCollisionException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
 // src/Container.ts
 var scopeStorage = new AsyncLocalStorage;
 
@@ -3681,6 +3791,17 @@ class Container {
       scope: "singleton"
     });
   }
+  singletonInline(namespace, key, factory) {
+    const namespacedKey = `inline:${namespace}:${key}`;
+    if (this.has(namespacedKey)) {
+      if (true) {
+        throw new ContainerBindingCollisionException(`Binding '${namespacedKey}' already registered by plugin '${namespace}'`);
+      }
+      console.warn(`[gravito] Binding '${namespacedKey}' collision detected \u2014 skipping duplicate registration.`);
+      return;
+    }
+    this.singleton(namespacedKey, factory);
+  }
   scoped(key, factory) {
     this.bindings.set(key, {
       factory,
@@ -6266,7 +6387,8 @@ class MessageQueueBridge {
       throw new Error(`[MessageQueueBridge] No listeners registered for event: ${eventName}`);
     }
     if (this.config.enableCircuitBreaker) {
-      const breaker = this.config.hookManager.getCircuitBreaker?.(eventName);
+      const hm = this.config.hookManager;
+      const breaker = hm.getCircuitBreaker?.(eventName);
       if (breaker?.getState?.() === "OPEN") {
         throw new Error(`[MessageQueueBridge] Circuit breaker is OPEN for event: ${eventName}`);
       }
@@ -6392,9 +6514,9 @@ class RetryScheduler {
     try {
       const queue = this.getOrCreateQueue(eventName);
       const delay = this.calculateDelay(retryCount);
-      const addMethod = queue.add;
-      if (typeof addMethod === "function") {
-        await addMethod.call(queue, "retry", { payload, error: error.message, retryCount }, { delay });
+      const queueObj = queue;
+      if (typeof queueObj.add === "function") {
+        await queueObj.add.call(queue, "retry", { payload, error: error.message, retryCount }, { delay });
       }
     } catch (schedulerError) {
       const err = schedulerError instanceof Error ? schedulerError : new Error(String(schedulerError));
@@ -8975,7 +9097,6 @@ export {
   throwIf,
   tap,
   setCookie,
-  setApp,
   router,
   registerQueueCommands,
   old,
@@ -9052,4 +9173,4 @@ export {
   Arr
 };
 
-//# debugId=004674489562A73F64756E2164756E21
+//# debugId=245BF91366B5C49E64756E2164756E21