@gravito/core 2.0.4 → 3.0.0

package/dist/index.js

@@ -1445,6 +1445,109 @@ var require_src = __commonJS((exports) => {
     trace: trace_api_1.trace
   };
 });
+
+// src/compat/async-local-storage.ts
+var AsyncLocalStorageClass;
+var tryGetNodeAsyncHooks = () => {
+  try {
+    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
+      try {
+        const module = __require("async_hooks");
+        return module.AsyncLocalStorage;
+      } catch (_e1) {
+        try {
+          return eval("require")("node:async_hooks").AsyncLocalStorage;
+        } catch (_e2) {
+          return null;
+        }
+      }
+    }
+  } catch (_e) {
+    return null;
+  }
+};
+AsyncLocalStorageClass = tryGetNodeAsyncHooks();
+if (!AsyncLocalStorageClass) {
+  AsyncLocalStorageClass = class AsyncLocalStorage {
+    store;
+    run(store, fn) {
+      const prev = this.store;
+      this.store = store;
+      try {
+        return fn();
+      } finally {
+        this.store = prev;
+      }
+    }
+    getStore() {
+      return this.store;
+    }
+    disable() {
+      this.store = undefined;
+    }
+  };
+}
+var AsyncLocalStorage = AsyncLocalStorageClass;
+
+// src/compat/crypto.ts
+var randomUUIDFn;
+var randomBytesFn;
+var tryGetNodeCrypto = () => {
+  try {
+    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
+      return eval("require")("node:crypto");
+    }
+  } catch (_e) {
+    return null;
+  }
+};
+var nodeCrypto = tryGetNodeCrypto();
+if (nodeCrypto) {
+  randomUUIDFn = nodeCrypto.randomUUID;
+  randomBytesFn = nodeCrypto.randomBytes;
+} else {
+  randomUUIDFn = () => {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+      return globalThis.crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  };
+  randomBytesFn = (size) => {
+    const bytes = new Uint8Array(size);
+    if (typeof globalThis.crypto?.getRandomValues === "function") {
+      globalThis.crypto.getRandomValues(bytes);
+    } else {
+      for (let i = 0;i < size; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    return {
+      ...Array.from(bytes),
+      length: size,
+      [Symbol.iterator]: () => bytes[Symbol.iterator](),
+      toString: (encoding) => {
+        if (encoding === "base64") {
+          let binary = "";
+          for (let i = 0;i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          return btoa(binary);
+        }
+        if (encoding === "hex") {
+          return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        }
+        return "";
+      }
+    };
+  };
+}
+var randomUUID = randomUUIDFn;
+var randomBytes = randomBytesFn;
+
 // src/ffi/hash-fallback.ts
 import { createHash, createHmac } from "crypto";
 
@@ -3197,7 +3300,7 @@ class Gravito {
 // package.json
 var package_default = {
   name: "@gravito/core",
-  version: "2.0.4",
+  version: "3.0.0",
   description: "",
   module: "./dist/index.js",
   main: "./dist/index.js",
@@ -3206,8 +3309,8 @@ var package_default = {
   types: "./dist/index.d.ts",
   exports: {
     ".": {
-      browser: "./src/index.browser.ts",
-      bun: "./src/index.ts",
+      browser: "./dist/index.browser.js",
+      bun: "./dist/index.js",
       types: "./dist/index.d.ts",
       default: "./dist/index.js"
     },
@@ -3224,12 +3327,12 @@ var package_default = {
       default: "./dist/ffi/index.js"
     },
     "./compat/async-local-storage": {
-      browser: "./src/compat/async-local-storage.browser.ts",
-      default: "./src/compat/async-local-storage.ts"
+      browser: "./dist/compat/async-local-storage.browser.js",
+      default: "./dist/compat/async-local-storage.js"
     },
     "./compat/crypto": {
-      browser: "./src/compat/crypto.browser.ts",
-      default: "./src/compat/crypto.ts"
+      browser: "./dist/compat/crypto.browser.js",
+      default: "./dist/compat/crypto.js"
     }
   },
   files: [
@@ -3923,6 +4026,9 @@ import path2 from "path";
 import { pathToFileURL } from "url";
 
 // src/runtime/adapter-bun.ts
+function createEphemeralPort() {
+  return Math.floor(Math.random() * 50000) + 1e4;
+}
 function createBunAdapter() {
   return {
     kind: "bun",
@@ -4130,11 +4236,26 @@ function createBunAdapter() {
       await fs2.rm(path2, { recursive: true, force: true });
     },
     serve(config2) {
-      return Bun.serve({
-        port: config2.port,
-        fetch: config2.fetch,
-        websocket: config2.websocket
-      });
+      if (config2.port !== 0) {
+        return Bun.serve({
+          port: config2.port,
+          fetch: config2.fetch,
+          websocket: config2.websocket
+        });
+      }
+      let lastError;
+      for (let attempt = 0;attempt < 20; attempt++) {
+        try {
+          return Bun.serve({
+            port: createEphemeralPort(),
+            fetch: config2.fetch,
+            websocket: config2.websocket
+          });
+        } catch (error) {
+          lastError = error;
+        }
+      }
+      throw lastError ?? new Error("[RuntimeAdapter] Failed to allocate an ephemeral port");
     }
   };
 }
@@ -5549,54 +5670,50 @@ class ConfigManager {
   }
 }
 
-// src/compat/async-local-storage.ts
-var AsyncLocalStorageClass;
-var tryGetNodeAsyncHooks = () => {
-  try {
-    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
-      try {
-        const module = __require("async_hooks");
-        return module.AsyncLocalStorage;
-      } catch (_e1) {
-        try {
-          return eval("require")("node:async_hooks").AsyncLocalStorage;
-        } catch (_e2) {
-          return null;
-        }
-      }
-    }
-  } catch (_e) {
-    return null;
-  }
-};
-AsyncLocalStorageClass = tryGetNodeAsyncHooks();
-if (!AsyncLocalStorageClass) {
-  AsyncLocalStorageClass = class AsyncLocalStorage {
-    store = null;
-    run(store, fn) {
-      const prev = this.store;
-      this.store = store;
-      try {
-        return fn();
-      } finally {
-        this.store = prev;
-      }
+// 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;
     }
-    getStore() {
-      return this.store || undefined;
+    if (options2.i18nParams) {
+      this.i18nParams = options2.i18nParams;
     }
-    disable() {
-      this.store = null;
+    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);
+  }
 }
-var AsyncLocalStorage = AsyncLocalStorageClass;
 
 // 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";
   }
 }
@@ -5762,33 +5879,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 = {}) {
@@ -5797,8 +5887,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;
@@ -5807,6 +5906,7 @@ class ValidationException extends GravitoException {
       message,
       i18nKey: "errors.validation.failed"
     });
+    this.name = "ValidationException";
     this.errors = errors;
   }
   withRedirect(url) {
@@ -8734,65 +8834,6 @@ class MigrationWarner {
   }
 }
 
-// src/compat/crypto.ts
-var randomUUIDFn;
-var randomBytesFn;
-var tryGetNodeCrypto = () => {
-  try {
-    if (typeof window === "undefined" && typeof process !== "undefined" && true) {
-      return eval("require")("node:crypto");
-    }
-  } catch (_e) {
-    return null;
-  }
-};
-var nodeCrypto = tryGetNodeCrypto();
-if (nodeCrypto) {
-  randomUUIDFn = nodeCrypto.randomUUID;
-  randomBytesFn = nodeCrypto.randomBytes;
-} else {
-  randomUUIDFn = () => {
-    if (typeof globalThis.crypto?.randomUUID === "function") {
-      return globalThis.crypto.randomUUID();
-    }
-    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-      const r = Math.random() * 16 | 0;
-      const v = c === "x" ? r : r & 3 | 8;
-      return v.toString(16);
-    });
-  };
-  randomBytesFn = (size) => {
-    const bytes = new Uint8Array(size);
-    if (typeof globalThis.crypto?.getRandomValues === "function") {
-      globalThis.crypto.getRandomValues(bytes);
-    } else {
-      for (let i = 0;i < size; i++) {
-        bytes[i] = Math.floor(Math.random() * 256);
-      }
-    }
-    return {
-      ...Array.from(bytes),
-      length: size,
-      [Symbol.iterator]: () => bytes[Symbol.iterator](),
-      toString: (encoding) => {
-        if (encoding === "base64") {
-          let binary = "";
-          for (let i = 0;i < bytes.byteLength; i++) {
-            binary += String.fromCharCode(bytes[i]);
-          }
-          return btoa(binary);
-        }
-        if (encoding === "hex") {
-          return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-        }
-        return "";
-      }
-    };
-  };
-}
-var randomUUID = randomUUIDFn;
-var randomBytes = randomBytesFn;
-
 // src/reliability/RetryPolicy.ts
 class RetryEngine {
   calculateDelay(attemptCount, policy) {
@@ -10902,6 +10943,7 @@ class ModelNotFoundException extends GravitoException {
       i18nKey: "errors.model.not_found",
       i18nParams: { model, id: String(id ?? "") }
     });
+    this.name = "ModelNotFoundException";
     this.model = model;
     if (id !== undefined) {
       this.id = id;
@@ -11457,6 +11499,7 @@ class PlanetCore {
   deferredProviders = new Map;
   bootedProviders = new Set;
   isShuttingDown = false;
+  static GLOBAL_SHUTDOWN_TIMEOUT = 1e4;
   async initializeObservabilityAsync(obsConfig) {
     try {
       if (this.observabilityProvider && this.observabilityProvider !== this.observabilityProvider._isNoOp) {
@@ -11558,15 +11601,23 @@ class PlanetCore {
     }
     this.isShuttingDown = true;
     this.logger.debug("\uD83D\uDED1 Application shutdown started");
-    for (const provider of [...this.providers].reverse()) {
-      if (provider.onShutdown) {
-        try {
-          this.logger.debug(`  onShutdown: ${provider.constructor.name}`);
-          await provider.onShutdown(this);
-        } catch (error) {
-          this.logger.error(`Error during shutdown of ${provider.constructor.name}:`, error);
+    const shutdownSequence = async () => {
+      for (const provider of [...this.providers].reverse()) {
+        if (provider.onShutdown) {
+          try {
+            this.logger.debug(`  onShutdown: ${provider.constructor.name}`);
+            await provider.onShutdown(this);
+          } catch (error) {
+            this.logger.error(`Error during shutdown of ${provider.constructor.name}:`, error);
+          }
         }
       }
+    };
+    const globalDeadline = new Promise((_, reject) => setTimeout(() => reject(new Error("[PlanetCore] Global shutdown timeout exceeded (10s)")), PlanetCore.GLOBAL_SHUTDOWN_TIMEOUT));
+    try {
+      await Promise.race([shutdownSequence(), globalDeadline]);
+    } catch (err) {
+      this.logger.warn("[PlanetCore] Forced shutdown after global timeout:", err);
     }
     this.hooks.doAction("app:shutdown", this);
     this.logger.debug("\u2705 Application shutdown complete");
@@ -12449,6 +12500,96 @@ class CompositeStrategy {
     return false;
   }
 }
+function createDefaultStrategies(_config) {
+  return [new QueueDepthStrategy, new RateLimitStrategy, new PriorityRebalanceStrategy];
+}
+// src/events/MessageQueueBridge.ts
+class MessageQueueBridge {
+  config;
+  constructor(config3) {
+    this.config = config3;
+    if (!config3.hookManager) {
+      throw new Error("MessageQueueBridge: hookManager is required");
+    }
+    if (!config3.eventBackend) {
+      throw new Error("MessageQueueBridge: eventBackend is required");
+    }
+    if (!config3.dlqManager) {
+      throw new Error("MessageQueueBridge: dlqManager is required");
+    }
+  }
+  async dispatchWithQueue(eventName, args, options2) {
+    const listeners = this.config.hookManager.getListeners(eventName);
+    if (listeners.length === 0) {
+      throw new Error(`[MessageQueueBridge] No listeners registered for event: ${eventName}`);
+    }
+    if (this.config.enableCircuitBreaker) {
+      const breaker = this.config.hookManager.getCircuitBreaker?.(eventName);
+      if (breaker?.getState?.() === "OPEN") {
+        throw new Error(`[MessageQueueBridge] Circuit breaker is OPEN for event: ${eventName}`);
+      }
+    }
+    const nowMs = Date.now();
+    const task = {
+      id: `queue-${nowMs}-${Math.random().toString(36).substr(2, 9)}`,
+      hook: eventName,
+      args,
+      callbacks: listeners,
+      options: options2 || {},
+      createdAt: nowMs,
+      enqueuedAt: nowMs,
+      retryCount: 0
+    };
+    const jobId = task.id;
+    await this.config.eventBackend.enqueue(task);
+    console.info(`[MessageQueueBridge] Event "${eventName}" enqueued to Bull Queue (job: ${jobId})`);
+    return jobId;
+  }
+  async processQueuedEvent(jobId, task) {
+    let hasError = false;
+    let lastError = null;
+    for (const callback of task.callbacks) {
+      try {
+        await callback(task.args);
+      } catch (error) {
+        hasError = true;
+        lastError = error;
+        console.error(`[MessageQueueBridge] Callback failed for event "${task.hook}" (job: ${jobId}):`, error);
+      }
+    }
+    if (hasError) {
+      console.error(`[MessageQueueBridge] Event "${task.hook}" processing failed (job: ${jobId})`);
+      throw lastError || new Error("Event processing failed");
+    }
+    console.info(`[MessageQueueBridge] Event "${task.hook}" processed successfully (job: ${jobId})`);
+  }
+  async handleJobFailure(jobId, task, error, retryCount = 0) {
+    console.warn(`[MessageQueueBridge] Event "${task.hook}" failed after retries (job: ${jobId}), moving to DLQ`);
+    try {
+      const dlqId = await this.config.dlqManager.moveToDlq(task.hook, task.args, task.options, error, retryCount);
+      console.info(`[MessageQueueBridge] Event moved to DLQ (dlq_id: ${dlqId})`);
+    } catch (dlqError) {
+      console.error(`[MessageQueueBridge] Failed to move event to DLQ:`, dlqError);
+    }
+  }
+  async getEventStatus(eventId) {
+    return {
+      eventId,
+      status: "pending",
+      attempts: 0,
+      createdAt: Date.now()
+    };
+  }
+  getEventBackend() {
+    return this.config.eventBackend;
+  }
+  getDLQManager() {
+    return this.config.dlqManager;
+  }
+  getHookManager() {
+    return this.config.hookManager;
+  }
+}
 // src/events/RetryScheduler.ts
 class RetryScheduler {
   enabled;
@@ -13081,22 +13222,98 @@ class QueueDashboard {
   }
 }
 // src/exceptions/AuthenticationException.ts
-class AuthenticationException extends GravitoException {
+class AuthenticationException extends DomainException {
   constructor(message = "Unauthenticated.") {
     super(401, "UNAUTHENTICATED", {
       message,
       i18nKey: "errors.authentication.unauthenticated"
     });
+    this.name = "AuthenticationException";
+  }
+}
+
+// src/exceptions/AuthException.ts
+class AuthException extends DomainException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "AuthException";
+    Object.setPrototypeOf(this, new.target.prototype);
   }
 }
 
 // src/exceptions/AuthorizationException.ts
-class AuthorizationException extends GravitoException {
+class AuthorizationException extends DomainException {
   constructor(message = "This action is unauthorized.") {
     super(403, "FORBIDDEN", {
       message,
       i18nKey: "errors.authorization.forbidden"
     });
+    this.name = "AuthorizationException";
+  }
+}
+
+// src/exceptions/InfrastructureException.ts
+class InfrastructureException extends GravitoException {
+  retryable;
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "InfrastructureException";
+    this.retryable = options2.retryable ?? false;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/CacheException.ts
+class CacheException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "CacheException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/ConfigurationException.ts
+class ConfigurationException extends SystemException {
+  constructor(message, options2 = {}) {
+    super(500, "system.configuration_error", { ...options2, message });
+    this.name = "ConfigurationException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/DatabaseException.ts
+class DatabaseException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "DatabaseException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/QueueException.ts
+class QueueException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "QueueException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/StorageException.ts
+class StorageException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "StorageException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/StreamException.ts
+class StreamException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "StreamException";
+    Object.setPrototypeOf(this, new.target.prototype);
   }
 }
 // src/ServiceProvider.ts
@@ -13422,19 +13639,35 @@ class HttpTester {
       body
     });
     const response2 = await this.core.adapter.fetch(request);
-    const setCookie2 = response2.headers.get("Set-Cookie");
-    if (setCookie2) {
-      const parts = setCookie2.split(/,(?=[^;]+=[^;]+)/);
-      for (const part of parts) {
-        const cookiePair = part.split(";")[0].trim();
-        const [name, ...valueParts] = cookiePair.split("=");
-        if (name) {
-          this.cookies.set(name, valueParts.join("="));
-        }
+    for (const setCookie2 of this.getSetCookieHeaders(response2.headers)) {
+      const cookiePair = setCookie2.split(";")[0]?.trim();
+      if (!cookiePair) {
+        continue;
+      }
+      const [name, ...valueParts] = cookiePair.split("=");
+      if (name) {
+        this.cookies.set(name, valueParts.join("="));
       }
     }
     return new TestResponse(response2);
   }
+  getSetCookieHeaders(headers) {
+    const headersWithGetSetCookie = headers;
+    const getSetCookie = headersWithGetSetCookie.getSetCookie?.();
+    if (getSetCookie && getSetCookie.length > 0) {
+      return getSetCookie;
+    }
+    const headerJson = headersWithGetSetCookie.toJSON?.();
+    const jsonSetCookie = headerJson?.["set-cookie"];
+    if (Array.isArray(jsonSetCookie)) {
+      return jsonSetCookie;
+    }
+    if (typeof jsonSetCookie === "string") {
+      return [jsonSetCookie];
+    }
+    const setCookie2 = headers.get("Set-Cookie");
+    return setCookie2 ? [setCookie2] : [];
+  }
 }
 function createHttpTester(core) {
   return new HttpTester(core);
@@ -13820,7 +14053,10 @@ export {
   ValidationException,
   VERSION,
   TestResponse,
+  SystemException,
+  StreamException,
   Str,
+  StorageException,
   StarvationProtectionStrategy,
   ServiceProvider,
   Router,
@@ -13836,6 +14072,7 @@ export {
   RateLimitStrategy,
   RadixRouter,
   RadixNode,
+  QueueException,
   QueueDepthStrategy,
   QueueDashboard,
   PriorityRebalanceStrategy,
@@ -13845,6 +14082,7 @@ export {
   OTelEventMetrics,
   NodeType,
   ModelNotFoundException,
+  InfrastructureException,
   IdempotencyCache,
   HttpTester,
   HttpException,
@@ -13863,18 +14101,22 @@ export {
   ErrorHandler,
   Encrypter,
   DumpDieError,
+  DomainException,
   DeadLetterQueueManager,
   DeadLetterQueue,
+  DatabaseException,
   DEFAULT_EVENT_OPTIONS,
   CookieJar,
   Container,
   ConsoleLogger,
+  ConfigurationException,
   ConfigManager,
   CompositeStrategy,
   CommandKernel,
   CircularDependencyException,
   CircuitBreakerState,
   CircuitBreaker,
+  CacheException,
   BunWebSocketHandler,
   BunRequest,
   BunNativeAdapter,
@@ -13884,8 +14126,9 @@ export {
   BackpressureManager,
   AuthorizationException,
   AuthenticationException,
+  AuthException,
   Arr,
   Application
 };
 
-//# debugId=E93F9E403DD7FBA964756E2164756E21
+//# debugId=182898C607162D4164756E2164756E21