@parsrun/queue 0.1.0

package/dist/adapters/index.js

@@ -0,0 +1,703 @@
+// src/types.ts
+import {
+  type,
+  jobStatus,
+  job,
+  jobOptions,
+  addJobRequest,
+  jobProgressUpdate,
+  queueStats,
+  queueListOptions,
+  redisQueueConfig,
+  workerOptions,
+  queueConfig
+} from "@parsrun/types";
+var QueueError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "QueueError";
+  }
+};
+var QueueErrorCodes = {
+  SEND_FAILED: "SEND_FAILED",
+  RECEIVE_FAILED: "RECEIVE_FAILED",
+  ACK_FAILED: "ACK_FAILED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  QUEUE_FULL: "QUEUE_FULL",
+  MESSAGE_NOT_FOUND: "MESSAGE_NOT_FOUND",
+  NOT_IMPLEMENTED: "NOT_IMPLEMENTED"
+};
+
+// src/adapters/memory.ts
+var MemoryQueueAdapter = class {
+  type = "memory";
+  name;
+  messages = [];
+  inFlight = /* @__PURE__ */ new Map();
+  processedIds = /* @__PURE__ */ new Set();
+  maxSize;
+  visibilityTimeout;
+  messageCounter = 0;
+  isConsuming = false;
+  consumeInterval = null;
+  constructor(config) {
+    this.name = config.name;
+    this.maxSize = config.maxSize ?? Infinity;
+    this.visibilityTimeout = config.visibilityTimeout ?? 30;
+  }
+  generateId() {
+    this.messageCounter++;
+    return `msg-${Date.now()}-${this.messageCounter}`;
+  }
+  async send(body, options) {
+    if (this.messages.length >= this.maxSize) {
+      throw new QueueError(
+        `Queue ${this.name} is full`,
+        QueueErrorCodes.QUEUE_FULL
+      );
+    }
+    if (options?.deduplicationId && this.processedIds.has(options.deduplicationId)) {
+      return `dedup-${options.deduplicationId}`;
+    }
+    const id = this.generateId();
+    const now = Date.now();
+    const visibleAt = options?.delaySeconds ? now + options.delaySeconds * 1e3 : now;
+    const message = {
+      id,
+      body,
+      timestamp: /* @__PURE__ */ new Date(),
+      attempts: 0,
+      visibleAt,
+      deduplicationId: options?.deduplicationId,
+      metadata: options?.metadata
+    };
+    if (options?.priority !== void 0 && options.priority > 0) {
+      const insertIndex = this.messages.findIndex(
+        (m) => m.metadata?.["priority"] ?? 0 < (options.priority ?? 0)
+      );
+      if (insertIndex === -1) {
+        this.messages.push(message);
+      } else {
+        this.messages.splice(insertIndex, 0, message);
+      }
+    } else {
+      this.messages.push(message);
+    }
+    if (options?.deduplicationId) {
+      this.processedIds.add(options.deduplicationId);
+    }
+    return id;
+  }
+  async sendBatch(messages) {
+    const messageIds = [];
+    const errors = [];
+    let successful = 0;
+    let failed = 0;
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (!msg) continue;
+      try {
+        const id = await this.send(msg.body, msg.options);
+        messageIds.push(id);
+        successful++;
+      } catch (err) {
+        failed++;
+        errors.push({
+          index: i,
+          error: err instanceof Error ? err.message : "Unknown error"
+        });
+      }
+    }
+    return {
+      total: messages.length,
+      successful,
+      failed,
+      messageIds,
+      errors
+    };
+  }
+  async receive(maxMessages = 10, visibilityTimeoutOverride) {
+    const now = Date.now();
+    const timeout = (visibilityTimeoutOverride ?? this.visibilityTimeout) * 1e3;
+    const result = [];
+    const visibleMessages = [];
+    const remainingMessages = [];
+    for (const msg of this.messages) {
+      if (msg.visibleAt <= now && visibleMessages.length < maxMessages) {
+        visibleMessages.push(msg);
+      } else {
+        remainingMessages.push(msg);
+      }
+    }
+    this.messages = remainingMessages;
+    for (const msg of visibleMessages) {
+      msg.attempts++;
+      msg.visibleAt = now + timeout;
+      this.inFlight.set(msg.id, msg);
+      result.push({
+        id: msg.id,
+        body: msg.body,
+        timestamp: msg.timestamp,
+        attempts: msg.attempts,
+        metadata: msg.metadata
+      });
+    }
+    return result;
+  }
+  async ack(messageId) {
+    const message = this.inFlight.get(messageId);
+    if (!message) {
+      throw new QueueError(
+        `Message ${messageId} not found in flight`,
+        QueueErrorCodes.MESSAGE_NOT_FOUND
+      );
+    }
+    this.inFlight.delete(messageId);
+  }
+  async ackBatch(messageIds) {
+    for (const id of messageIds) {
+      this.inFlight.delete(id);
+    }
+  }
+  async nack(messageId, delaySeconds) {
+    const message = this.inFlight.get(messageId);
+    if (!message) {
+      throw new QueueError(
+        `Message ${messageId} not found in flight`,
+        QueueErrorCodes.MESSAGE_NOT_FOUND
+      );
+    }
+    this.inFlight.delete(messageId);
+    const now = Date.now();
+    message.visibleAt = delaySeconds ? now + delaySeconds * 1e3 : now;
+    this.messages.push(message);
+  }
+  async consume(handler, options) {
+    if (this.isConsuming) {
+      return;
+    }
+    this.isConsuming = true;
+    const batchSize = options?.batchSize ?? 10;
+    const pollingInterval = options?.pollingInterval ?? 1e3;
+    const visibilityTimeout = options?.visibilityTimeout ?? this.visibilityTimeout;
+    const maxRetries = options?.maxRetries ?? 3;
+    const concurrency = options?.concurrency ?? 1;
+    const processMessages = async () => {
+      if (!this.isConsuming) return;
+      const messages = await this.receive(batchSize, visibilityTimeout);
+      for (let i = 0; i < messages.length; i += concurrency) {
+        const batch = messages.slice(i, i + concurrency);
+        await Promise.all(
+          batch.map(async (msg) => {
+            try {
+              await handler(msg);
+              await this.ack(msg.id);
+            } catch (err) {
+              if (msg.attempts >= maxRetries) {
+                await this.ack(msg.id);
+                console.error(
+                  `[Queue ${this.name}] Message ${msg.id} exceeded max retries, dropped`
+                );
+              } else {
+                await this.nack(msg.id, 5);
+              }
+            }
+          })
+        );
+      }
+    };
+    this.consumeInterval = setInterval(processMessages, pollingInterval);
+    await processMessages();
+  }
+  async stopConsuming() {
+    this.isConsuming = false;
+    if (this.consumeInterval) {
+      clearInterval(this.consumeInterval);
+      this.consumeInterval = null;
+    }
+  }
+  async getStats() {
+    const now = Date.now();
+    for (const [id, msg] of this.inFlight) {
+      if (msg.visibleAt <= now) {
+        this.inFlight.delete(id);
+        this.messages.push(msg);
+      }
+    }
+    return {
+      messageCount: this.messages.length,
+      inFlightCount: this.inFlight.size
+    };
+  }
+  async purge() {
+    this.messages = [];
+    this.inFlight.clear();
+  }
+  async close() {
+    await this.stopConsuming();
+    await this.purge();
+    this.processedIds.clear();
+  }
+};
+function createMemoryQueueAdapter(config) {
+  return new MemoryQueueAdapter(config);
+}
+
+// src/adapters/cloudflare.ts
+var CloudflareQueueAdapter = class {
+  type = "cloudflare";
+  name = "cloudflare-queue";
+  queue;
+  constructor(config) {
+    this.queue = config.queue;
+  }
+  async send(body, options) {
+    try {
+      await this.queue.send(body, {
+        delaySeconds: options?.delaySeconds
+      });
+      return `cf-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    } catch (err) {
+      throw new QueueError(
+        `Cloudflare Queue send failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+  async sendBatch(messages) {
+    try {
+      const batchMessages = messages.map((m) => ({
+        body: m.body,
+        delaySeconds: m.options?.delaySeconds
+      }));
+      await this.queue.sendBatch(batchMessages);
+      const messageIds = messages.map(
+        () => `cf-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
+      );
+      return {
+        total: messages.length,
+        successful: messages.length,
+        failed: 0,
+        messageIds,
+        errors: []
+      };
+    } catch (err) {
+      throw new QueueError(
+        `Cloudflare Queue batch send failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+  // Cloudflare Queues are push-based, so receive is not applicable
+  // Messages are delivered to queue handlers via Workers
+};
+var CloudflareQueueProcessor = class {
+  /**
+   * Process a batch of messages from Cloudflare Queues
+   */
+  async processBatch(batch, handler, options) {
+    let processed = 0;
+    let failed = 0;
+    for (const msg of batch.messages) {
+      try {
+        const queueMessage = {
+          id: msg.id,
+          body: msg.body,
+          timestamp: msg.timestamp,
+          attempts: msg.attempts
+        };
+        await handler(queueMessage);
+        if (!options?.ackAll) {
+          msg.ack();
+        }
+        processed++;
+      } catch (err) {
+        failed++;
+        if (options?.retryAllOnFailure) {
+          batch.retryAll();
+          return { processed, failed: batch.messages.length };
+        }
+        msg.retry();
+      }
+    }
+    if (options?.ackAll && failed === 0) {
+      batch.ackAll();
+    }
+    return { processed, failed };
+  }
+  /**
+   * Convert a Cloudflare message to QueueMessage format
+   */
+  toQueueMessage(msg) {
+    return {
+      id: msg.id,
+      body: msg.body,
+      timestamp: msg.timestamp,
+      attempts: msg.attempts
+    };
+  }
+};
+function createCloudflareQueueAdapter(config) {
+  return new CloudflareQueueAdapter(config);
+}
+function createCloudflareQueueProcessor() {
+  return new CloudflareQueueProcessor();
+}
+
+// src/adapters/qstash.ts
+var QStashAdapter = class {
+  type = "qstash";
+  name = "qstash";
+  token;
+  destinationUrl;
+  baseUrl = "https://qstash.upstash.io/v2";
+  constructor(config) {
+    this.token = config.token;
+    this.destinationUrl = config.destinationUrl;
+  }
+  async send(body, options) {
+    try {
+      const headers = {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      };
+      if (options?.delaySeconds) {
+        headers["Upstash-Delay"] = `${options.delaySeconds}s`;
+      }
+      if (options?.deduplicationId) {
+        headers["Upstash-Deduplication-Id"] = options.deduplicationId;
+      }
+      if (options?.metadata) {
+        for (const [key, value] of Object.entries(options.metadata)) {
+          if (typeof value === "string") {
+            headers[`Upstash-Forward-${key}`] = value;
+          }
+        }
+      }
+      const response = await fetch(
+        `${this.baseUrl}/publish/${encodeURIComponent(this.destinationUrl)}`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        }
+      );
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`QStash API error: ${error}`);
+      }
+      const result = await response.json();
+      return result.messageId;
+    } catch (err) {
+      throw new QueueError(
+        `QStash send failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+  async sendBatch(messages) {
+    try {
+      const batchMessages = messages.map((m) => {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (m.options?.delaySeconds) {
+          headers["Upstash-Delay"] = `${m.options.delaySeconds}s`;
+        }
+        if (m.options?.deduplicationId) {
+          headers["Upstash-Deduplication-Id"] = m.options.deduplicationId;
+        }
+        return {
+          destination: this.destinationUrl,
+          headers,
+          body: JSON.stringify(m.body)
+        };
+      });
+      const response = await fetch(`${this.baseUrl}/batch`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(batchMessages)
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`QStash API error: ${error}`);
+      }
+      const results = await response.json();
+      const messageIds = [];
+      const errors = [];
+      let successful = 0;
+      let failed = 0;
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result?.messageId) {
+          messageIds.push(result.messageId);
+          successful++;
+        } else {
+          failed++;
+          errors.push({
+            index: i,
+            error: result?.error ?? "Unknown error"
+          });
+        }
+      }
+      return {
+        total: messages.length,
+        successful,
+        failed,
+        messageIds,
+        errors
+      };
+    } catch (err) {
+      throw new QueueError(
+        `QStash batch send failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+  /**
+   * Schedule a message for future delivery
+   */
+  async schedule(body, cronExpression, options) {
+    try {
+      const headers = {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+        "Upstash-Cron": cronExpression
+      };
+      if (options?.deduplicationId) {
+        headers["Upstash-Deduplication-Id"] = options.deduplicationId;
+      }
+      const response = await fetch(
+        `${this.baseUrl}/schedules/${encodeURIComponent(this.destinationUrl)}`,
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body)
+        }
+      );
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`QStash API error: ${error}`);
+      }
+      const result = await response.json();
+      return result.scheduleId;
+    } catch (err) {
+      throw new QueueError(
+        `QStash schedule failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+  /**
+   * Delete a scheduled message
+   */
+  async deleteSchedule(scheduleId) {
+    try {
+      const response = await fetch(`${this.baseUrl}/schedules/${scheduleId}`, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`QStash API error: ${error}`);
+      }
+    } catch (err) {
+      throw new QueueError(
+        `QStash delete schedule failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+  /**
+   * List all schedules
+   */
+  async listSchedules() {
+    try {
+      const response = await fetch(`${this.baseUrl}/schedules`, {
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`QStash API error: ${error}`);
+      }
+      return await response.json();
+    } catch (err) {
+      throw new QueueError(
+        `QStash list schedules failed: ${err instanceof Error ? err.message : "Unknown error"}`,
+        QueueErrorCodes.SEND_FAILED,
+        err
+      );
+    }
+  }
+};
+var QStashReceiver = class {
+  currentSigningKey;
+  nextSigningKey;
+  constructor(config) {
+    this.currentSigningKey = config.currentSigningKey;
+    this.nextSigningKey = config.nextSigningKey;
+  }
+  /**
+   * Verify a request from QStash and extract the message
+   */
+  async verify(request) {
+    const signature = request.headers.get("Upstash-Signature");
+    if (!signature) {
+      return null;
+    }
+    const body = await request.text();
+    const isValid = await this.verifySignature(body, signature, this.currentSigningKey) || await this.verifySignature(body, signature, this.nextSigningKey);
+    if (!isValid) {
+      return null;
+    }
+    const messageId = request.headers.get("Upstash-Message-Id") ?? `qstash-${Date.now()}`;
+    const retryCount = parseInt(
+      request.headers.get("Upstash-Retried") ?? "0",
+      10
+    );
+    let parsedBody;
+    try {
+      parsedBody = JSON.parse(body);
+    } catch {
+      parsedBody = body;
+    }
+    return {
+      id: messageId,
+      body: parsedBody,
+      timestamp: /* @__PURE__ */ new Date(),
+      attempts: retryCount + 1
+    };
+  }
+  async verifySignature(body, signature, key) {
+    try {
+      const parts = signature.split(".");
+      if (parts.length !== 3) {
+        return false;
+      }
+      const [headerB64, payloadB64, signatureB64] = parts;
+      if (!headerB64 || !payloadB64 || !signatureB64) {
+        return false;
+      }
+      const encoder = new TextEncoder();
+      const keyData = encoder.encode(key);
+      const cryptoKey = await crypto.subtle.importKey(
+        "raw",
+        keyData,
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["verify"]
+      );
+      const signatureData = this.base64UrlDecode(signatureB64);
+      const dataToVerify = encoder.encode(`${headerB64}.${payloadB64}`);
+      const isValid = await crypto.subtle.verify(
+        "HMAC",
+        cryptoKey,
+        signatureData,
+        dataToVerify
+      );
+      if (!isValid) {
+        return false;
+      }
+      const payload = JSON.parse(atob(payloadB64));
+      const now = Math.floor(Date.now() / 1e3);
+      if (payload.exp && payload.exp < now) {
+        return false;
+      }
+      if (payload.nbf && payload.nbf > now) {
+        return false;
+      }
+      if (payload.body) {
+        const bodyHash = await this.sha256(body);
+        const expectedHash = this.base64UrlEncode(
+          new Uint8Array(
+            atob(payload.body).split("").map((c) => c.charCodeAt(0))
+          )
+        );
+        if (bodyHash !== expectedHash && payload.body !== bodyHash) {
+          const directHash = await this.sha256Base64(body);
+          if (directHash !== payload.body) {
+            return false;
+          }
+        }
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  base64UrlDecode(str) {
+    const base64 = str.replace(/-/g, "+").replace(/_/g, "/");
+    const padding = (4 - base64.length % 4) % 4;
+    const padded = base64 + "=".repeat(padding);
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  base64UrlEncode(data) {
+    let binary = "";
+    for (let i = 0; i < data.length; i++) {
+      const byte = data[i];
+      if (byte !== void 0) {
+        binary += String.fromCharCode(byte);
+      }
+    }
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  }
+  async sha256(message) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(message);
+    const hash = await crypto.subtle.digest("SHA-256", data);
+    return this.base64UrlEncode(new Uint8Array(hash));
+  }
+  async sha256Base64(message) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(message);
+    const hash = await crypto.subtle.digest("SHA-256", data);
+    let binary = "";
+    const bytes = new Uint8Array(hash);
+    for (let i = 0; i < bytes.length; i++) {
+      const byte = bytes[i];
+      if (byte !== void 0) {
+        binary += String.fromCharCode(byte);
+      }
+    }
+    return btoa(binary);
+  }
+};
+function createQStashAdapter(config) {
+  return new QStashAdapter(config);
+}
+function createQStashReceiver(config) {
+  return new QStashReceiver(config);
+}
+export {
+  CloudflareQueueAdapter,
+  CloudflareQueueProcessor,
+  MemoryQueueAdapter,
+  QStashAdapter,
+  QStashReceiver,
+  createCloudflareQueueAdapter,
+  createCloudflareQueueProcessor,
+  createMemoryQueueAdapter,
+  createQStashAdapter,
+  createQStashReceiver
+};
+//# sourceMappingURL=index.js.map