@gravito/core 2.0.3 → 2.0.6

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.3",
+  version: "2.0.6",
   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,49 +5670,6 @@ 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;
-      }
-    }
-    getStore() {
-      return this.store || undefined;
-    }
-    disable() {
-      this.store = null;
-    }
-  };
-}
-var AsyncLocalStorage = AsyncLocalStorageClass;
-
 // src/exceptions/CircularDependencyException.ts
 class CircularDependencyException extends Error {
   constructor(key, stack) {
@@ -8734,65 +8812,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) {
@@ -12449,6 +12468,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;
@@ -13422,19 +13531,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);
@@ -13888,4 +14013,4 @@ export {
   Application
 };
 
-//# debugId=72B44EAE02419EE064756E2164756E21
+//# debugId=B420456F9068F67364756E2164756E21