autotel-subscribers 31.0.4 → 31.1.0

package/dist/factories.cjs

@@ -15636,43 +15636,157 @@ var SegmentSubscriber = class {
   }
 };
 
+// src/http-client.ts
+async function parseBody(response) {
+  const text = await response.text();
+  if (text.trim().length === 0) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function isTimeoutError(error) {
+  if (!(error instanceof Error)) return false;
+  return error.name === "AbortError" || error.name === "TimeoutError";
+}
+function createHttpClient(options = {}) {
+  const defaultTimeoutMs = options.timeoutMs ?? 3e4;
+  return {
+    async request(url, requestOptions = {}) {
+      const timeoutMs = requestOptions.timeoutMs ?? defaultTimeoutMs;
+      const controller = new AbortController();
+      const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const response = await fetch(url, {
+          method: requestOptions.method ?? "GET",
+          headers: requestOptions.headers,
+          body: requestOptions.body,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          const body = await parseBody(response);
+          return {
+            ok: false,
+            kind: "http",
+            status: response.status,
+            statusText: response.statusText,
+            body
+          };
+        }
+        const data = await parseBody(response);
+        return { ok: true, status: response.status, data };
+      } catch (error) {
+        const cause = error instanceof Error ? error : new Error(String(error));
+        return {
+          ok: false,
+          kind: "network",
+          timedOut: isTimeoutError(error),
+          cause
+        };
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  };
+}
+
+// src/retry-classification.ts
+var SubscriberProviderError = class extends Error {
+  code;
+  retriable;
+  details;
+  constructor(options) {
+    super(options.message, options.cause ? { cause: options.cause } : void 0);
+    this.name = "SubscriberProviderError";
+    this.code = options.code;
+    this.retriable = options.retriable;
+    this.details = options.details;
+  }
+};
+function mapHttpStatus(status) {
+  switch (status) {
+    case 400:
+    case 422: {
+      return { code: "VALIDATION", retriable: false };
+    }
+    case 401:
+    case 403:
+    case 404: {
+      return { code: "CONFIG", retriable: false };
+    }
+    case 429: {
+      return { code: "RATE_LIMITED", retriable: true };
+    }
+    default: {
+      return { code: "PROVIDER", retriable: status >= 500 };
+    }
+  }
+}
+function isProviderRetriable(error) {
+  if (error instanceof SubscriberProviderError) return error.retriable;
+  return true;
+}
+
 // src/webhook.ts
 var WebhookSubscriber = class {
   name = "WebhookSubscriber";
-  version = "1.0.0";
+  version = "1.1.0";
   config;
   enabled;
   pendingRequests = /* @__PURE__ */ new Set();
+  httpClient;
   constructor(config) {
     this.config = config;
     this.enabled = config.enabled ?? true;
+    this.httpClient = createHttpClient({ timeoutMs: config.timeoutMs });
+  }
+  async delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
   }
   async send(payload) {
     if (!this.enabled) return;
     const maxRetries = this.config.maxRetries ?? 3;
+    const retryDelayMs = this.config.retryDelayMs ?? 1e3;
+    const method = this.config.method ?? "POST";
     let lastError;
-    for (let attempt2 = 0; attempt2 < maxRetries; attempt2++) {
-      try {
-        const response = await fetch(this.config.url, {
-          method: "POST",
+    for (let attempt2 = 1; attempt2 <= maxRetries; attempt2++) {
+      const response = await this.httpClient.request(
+        this.config.url,
+        {
+          method,
           headers: {
             "Content-Type": "application/json",
             ...this.config.headers
           },
-          body: JSON.stringify(payload)
-        });
-        if (!response.ok) {
-          throw new Error(`Webhook returned ${response.status}: ${response.statusText}`);
-        }
-        return;
-      } catch (error) {
-        lastError = error;
-        if (attempt2 < maxRetries - 1) {
-          await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt2) * 1e3));
+          body: JSON.stringify(payload),
+          timeoutMs: this.config.timeoutMs
         }
+      );
+      if (response.ok) return;
+      if (response.kind === "network") {
+        lastError = new SubscriberProviderError({
+          message: response.timedOut ? "Webhook request timed out" : "Webhook network request failed",
+          code: "NETWORK",
+          retriable: true,
+          details: response.cause,
+          cause: response.cause
+        });
+      } else {
+        const mapped = mapHttpStatus(response.status);
+        lastError = new SubscriberProviderError({
+          message: `Webhook returned ${response.status}: ${response.statusText}`,
+          code: mapped.code,
+          retriable: mapped.retriable,
+          details: response.body
+        });
       }
+      const canRetry = isProviderRetriable(lastError) && attempt2 < maxRetries;
+      if (!canRetry) break;
+      const backoffMs = retryDelayMs * 2 ** (attempt2 - 1);
+      await this.delay(backoffMs);
     }
-    console.error(`Webhook subscriber failed after ${maxRetries} attempts:`, lastError);
+    throw lastError ?? new Error("Webhook send failed");
   }
   async trackEvent(name, attributes, options) {
     const request = this.send({
@@ -15723,11 +15837,11 @@ var WebhookSubscriber = class {
   }
   trackRequest(request) {
     this.pendingRequests.add(request);
-    void request.finally(() => {
+    void request.catch(() => {
+    }).finally(() => {
       this.pendingRequests.delete(request);
     });
   }
-  /** Wait for all pending webhook requests to complete */
   async shutdown() {
     if (this.pendingRequests.size > 0) {
       await Promise.allSettled(this.pendingRequests);
@@ -16162,23 +16276,160 @@ function createSlackSubscriber(config) {
 function createMockSubscriber() {
   return new MockEventSubscriber();
 }
-function composeSubscribers(adapters) {
+function backoffDelay(attempt2, initialMs, maxMs) {
+  return Math.min(maxMs, initialMs * 2 ** (attempt2 - 1));
+}
+async function callSubscriber(subscriber, call) {
+  switch (call.method) {
+    case "trackEvent": {
+      await subscriber.trackEvent(
+        call.args[0],
+        call.args[1],
+        call.args[2]
+      );
+      return;
+    }
+    case "trackFunnelStep": {
+      await subscriber.trackFunnelStep(
+        call.args[0],
+        call.args[1],
+        call.args[2],
+        call.args[3]
+      );
+      return;
+    }
+    case "trackOutcome": {
+      await subscriber.trackOutcome(
+        call.args[0],
+        call.args[1],
+        call.args[2],
+        call.args[3]
+      );
+      return;
+    }
+    case "trackValue": {
+      await subscriber.trackValue(
+        call.args[0],
+        call.args[1],
+        call.args[2],
+        call.args[3]
+      );
+    }
+  }
+}
+function composeSubscribers(subscribers, options = {}) {
+  const strategy = options.strategy ?? "parallel";
+  const name = options.name ?? `ComposedSubscriber(${strategy})`;
+  const maxAttempts = options.maxAttemptsPerSubscriber ?? 1;
+  const initialRetryDelayMs = options.initialRetryDelayMs ?? 250;
+  const maxRetryDelayMs = options.maxRetryDelayMs ?? 1e4;
+  const isRetriable = options.isRetriable ?? (() => true);
+  const logger = options.logger ?? console;
+  let rrCounter = 0;
+  const sendOne = async (subscriber, call) => {
+    let lastError;
+    for (let attempt2 = 1; attempt2 <= maxAttempts; attempt2++) {
+      try {
+        await callSubscriber(subscriber, call);
+        return;
+      } catch (error) {
+        lastError = error;
+        const retryable = isRetriable(error);
+        logger.warn?.("composeSubscribers attempt failed", {
+          subscriber: subscriber.name,
+          attempt: attempt2,
+          retryable,
+          strategy,
+          error
+        });
+        if (!retryable || attempt2 >= maxAttempts) break;
+        await new Promise(
+          (resolve) => setTimeout(resolve, backoffDelay(attempt2, initialRetryDelayMs, maxRetryDelayMs))
+        );
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  };
+  const orderForSequential = () => {
+    const n = subscribers.length;
+    if (n === 0) return [];
+    if (strategy === "failover") {
+      return Array.from({ length: n }, (_, i) => i);
+    }
+    const start = strategy === "random" ? Math.floor(Math.random() * n) : rrCounter++ % n;
+    return Array.from({ length: n }, (_, i) => (start + i) % n);
+  };
+  const execute = async (call) => {
+    if (subscribers.length === 0) return;
+    if (strategy === "parallel") {
+      await Promise.all(subscribers.map((subscriber) => sendOne(subscriber, call)));
+      return;
+    }
+    if (strategy === "race") {
+      const attempts = subscribers.map(async (subscriber) => {
+        await sendOne(subscriber, call);
+        return subscriber.name ?? "unknown";
+      });
+      try {
+        await Promise.any(attempts);
+      } catch (error) {
+        if (error instanceof AggregateError && error.errors.length > 0) {
+          throw error.errors.at(-1);
+        }
+        throw error;
+      }
+      return;
+    }
+    if (strategy === "mirrored") {
+      const primary = subscribers[0];
+      if (!primary) return;
+      await sendOne(primary, call);
+      for (const mirror of subscribers.slice(1)) {
+        void sendOne(mirror, call).catch((error) => {
+          logger.warn?.("composeSubscribers mirror failed", {
+            subscriber: mirror.name,
+            error
+          });
+        });
+      }
+      return;
+    }
+    const order = orderForSequential();
+    let lastError;
+    for (const index of order) {
+      const subscriber = subscribers[index];
+      if (!subscriber) continue;
+      try {
+        await sendOne(subscriber, call);
+        return;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  };
   return {
-    name: "ComposedSubscriber",
-    async trackEvent(name, attributes) {
-      await Promise.all(adapters.map((a) => a.trackEvent(name, attributes)));
+    name,
+    async trackEvent(name_, attributes, options_) {
+      await execute({ method: "trackEvent", args: [name_, attributes, options_] });
     },
-    async trackFunnelStep(funnel, step, attributes) {
-      await Promise.all(adapters.map((a) => a.trackFunnelStep(funnel, step, attributes)));
+    async trackFunnelStep(funnel, step, attributes, options_) {
+      await execute({
+        method: "trackFunnelStep",
+        args: [funnel, step, attributes, options_]
+      });
     },
-    async trackOutcome(operation, outcome, attributes) {
-      await Promise.all(adapters.map((a) => a.trackOutcome(operation, outcome, attributes)));
+    async trackOutcome(operation, outcome, attributes, options_) {
+      await execute({
+        method: "trackOutcome",
+        args: [operation, outcome, attributes, options_]
+      });
     },
-    async trackValue(name, value, attributes) {
-      await Promise.all(adapters.map((a) => a.trackValue(name, value, attributes)));
+    async trackValue(name_, value, attributes, options_) {
+      await execute({ method: "trackValue", args: [name_, value, attributes, options_] });
     },
     async shutdown() {
-      await Promise.all(adapters.map((a) => a.shutdown?.()));
+      await Promise.all(subscribers.map(async (subscriber) => subscriber.shutdown?.()));
     }
   };
 }