@gravito/core 2.0.6 → 3.0.1

package/dist/index.browser.js

@@ -149,7 +149,7 @@ var randomBytes = randomBytesFn;
 // package.json
 var package_default = {
   name: "@gravito/core",
-  version: "2.0.6",
+  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;
@@ -3609,15 +3710,63 @@ class ConfigManager {
     }
   }
 }
+// src/exceptions/GravitoException.ts
+class GravitoException extends Error {
+  status;
+  code;
+  i18nKey;
+  i18nParams;
+  constructor(status, code, options2 = {}) {
+    super(options2.message);
+    this.name = "GravitoException";
+    this.status = status;
+    this.cause = options2.cause;
+    this.code = code;
+    if (options2.i18nKey) {
+      this.i18nKey = options2.i18nKey;
+    }
+    if (options2.i18nParams) {
+      this.i18nParams = options2.i18nParams;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  getLocalizedMessage(t) {
+    if (this.i18nKey) {
+      return t(this.i18nKey, this.i18nParams);
+    }
+    return this.message;
+  }
+}
+
+// src/exceptions/SystemException.ts
+class SystemException extends GravitoException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "SystemException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
 // src/exceptions/CircularDependencyException.ts
-class CircularDependencyException extends Error {
+class CircularDependencyException extends SystemException {
   constructor(key, stack) {
     const path2 = [...stack, key].map(String).join(" -> ");
-    super(`Circular dependency detected: ${path2}`);
+    super(500, "system.circular_dependency", {
+      message: `Circular dependency detected: ${path2}`
+    });
     this.name = "CircularDependencyException";
   }
 }
 
+// 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;
 
@@ -3642,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,
@@ -4107,33 +4267,6 @@ function detectRequestScopeLeaks(context) {
   };
 }
 
-// src/exceptions/GravitoException.ts
-class GravitoException extends Error {
-  status;
-  code;
-  i18nKey;
-  i18nParams;
-  constructor(status, code, options2 = {}) {
-    super(options2.message);
-    this.name = "GravitoException";
-    this.status = status;
-    this.cause = options2.cause;
-    this.code = code;
-    if (options2.i18nKey) {
-      this.i18nKey = options2.i18nKey;
-    }
-    if (options2.i18nParams) {
-      this.i18nParams = options2.i18nParams;
-    }
-  }
-  getLocalizedMessage(t) {
-    if (this.i18nKey) {
-      return t(this.i18nKey, this.i18nParams);
-    }
-    return this.message;
-  }
-}
-
 // src/exceptions/HttpException.ts
 class HttpException extends GravitoException {
   constructor(status, options2 = {}) {
@@ -4142,8 +4275,17 @@ class HttpException extends GravitoException {
   }
 }
 
+// src/exceptions/DomainException.ts
+class DomainException extends GravitoException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "DomainException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
 // src/exceptions/ValidationException.ts
-class ValidationException extends GravitoException {
+class ValidationException extends DomainException {
   errors;
   redirectTo;
   input;
@@ -4152,6 +4294,7 @@ class ValidationException extends GravitoException {
       message,
       i18nKey: "errors.validation.failed"
     });
+    this.name = "ValidationException";
     this.errors = errors;
   }
   withRedirect(url) {
@@ -6244,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}`);
       }
@@ -6370,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));
@@ -8953,7 +9097,6 @@ export {
   throwIf,
   tap,
   setCookie,
-  setApp,
   router,
   registerQueueCommands,
   old,
@@ -9030,4 +9173,4 @@ export {
   Arr
 };
 
-//# debugId=1C1545AE2FF7EA4564756E2164756E21
+//# debugId=245BF91366B5C49E64756E2164756E21