@parsrun/queue 0.1.0

package/README.md

@@ -0,0 +1,158 @@
+# @parsrun/queue
+
+Edge-compatible message queues for Pars with multiple adapter support.
+
+## Features
+
+- **Multi-Adapter**: Memory, Cloudflare Queues, Upstash QStash
+- **Edge-Compatible**: Works on all runtimes
+- **Delayed Jobs**: Schedule jobs for later
+- **Retries**: Automatic retry with backoff
+- **Dead Letter Queue**: Failed job handling
+
+## Installation
+
+```bash
+pnpm add @parsrun/queue
+```
+
+## Quick Start
+
+```typescript
+import { createQueue } from '@parsrun/queue';
+
+const queue = createQueue({
+  adapter: 'memory', // or 'cloudflare', 'qstash'
+});
+
+// Publish message
+await queue.publish('email:send', {
+  to: 'user@example.com',
+  subject: 'Hello',
+});
+
+// Subscribe to messages
+queue.subscribe('email:send', async (message) => {
+  await sendEmail(message.data);
+});
+```
+
+## API Overview
+
+### Adapters
+
+#### Memory (Development)
+
+```typescript
+import { createMemoryQueue } from '@parsrun/queue/adapters/memory';
+
+const queue = createMemoryQueue({
+  concurrency: 5,
+});
+```
+
+#### Cloudflare Queues
+
+```typescript
+import { createCloudflareQueue } from '@parsrun/queue/adapters/cloudflare';
+
+// In Cloudflare Worker
+const queue = createCloudflareQueue({
+  queue: env.MY_QUEUE,
+});
+```
+
+#### Upstash QStash
+
+```typescript
+import { createQStashQueue } from '@parsrun/queue/adapters/qstash';
+
+const queue = createQStashQueue({
+  token: process.env.QSTASH_TOKEN,
+  currentSigningKey: process.env.QSTASH_CURRENT_SIGNING_KEY,
+  nextSigningKey: process.env.QSTASH_NEXT_SIGNING_KEY,
+});
+```
+
+### Publishing Messages
+
+```typescript
+// Simple publish
+await queue.publish('topic', { data: 'value' });
+
+// With options
+await queue.publish('topic', data, {
+  delay: 60,         // Delay in seconds
+  retries: 3,        // Max retries
+  deduplicationId: 'unique-id',
+});
+
+// Batch publish
+await queue.publishBatch('topic', [
+  { data: 'item1' },
+  { data: 'item2' },
+]);
+```
+
+### Subscribing to Messages
+
+```typescript
+queue.subscribe('topic', async (message) => {
+  console.log(message.id, message.data);
+
+  // Throw to retry
+  if (shouldRetry) {
+    throw new Error('Retry later');
+  }
+});
+
+// With options
+queue.subscribe('topic', handler, {
+  concurrency: 5,
+  maxRetries: 3,
+  retryDelay: 1000,
+});
+```
+
+### Scheduled Jobs
+
+```typescript
+// Schedule for specific time
+await queue.schedule('cleanup', { type: 'daily' }, {
+  runAt: new Date('2024-01-01T00:00:00Z'),
+});
+
+// Cron-like scheduling (QStash)
+await queue.schedule('reports', { type: 'weekly' }, {
+  cron: '0 9 * * 1', // Every Monday at 9am
+});
+```
+
+### Dead Letter Queue
+
+```typescript
+const queue = createQueue({
+  adapter: 'memory',
+  deadLetterQueue: {
+    enabled: true,
+    maxRetries: 5,
+    onDeadLetter: async (message) => {
+      // Handle permanently failed message
+      await notifyAdmin(message);
+    },
+  },
+});
+```
+
+## Exports
+
+```typescript
+import { ... } from '@parsrun/queue';                    // Main exports
+import { ... } from '@parsrun/queue/adapters/memory';     // Memory adapter
+import { ... } from '@parsrun/queue/adapters/cloudflare'; // Cloudflare Queues
+import { ... } from '@parsrun/queue/adapters/qstash';     // Upstash QStash
+```
+
+## License
+
+MIT

package/dist/adapters/cloudflare.d.ts

@@ -0,0 +1,94 @@
+import { QueueAdapter, CloudflareQueueConfig, SendMessageOptions, BatchSendResult, CloudflareMessageBatch, QueueMessage, CloudflareMessage } from '../types.js';
+import '@parsrun/types';
+
+/**
+ * @parsrun/queue - Cloudflare Queues Adapter
+ * Adapter for Cloudflare Workers Queues
+ */
+
+/**
+ * Cloudflare Queue Adapter
+ * Uses Cloudflare Workers Queues for serverless message processing
+ *
+ * Cloudflare Queues uses a push-based model where messages are delivered
+ * to queue consumers via Workers.
+ *
+ * @example
+ * ```typescript
+ * // In your Worker
+ * export default {
+ *   async fetch(request, env) {
+ *     const queue = new CloudflareQueueAdapter({
+ *       queue: env.MY_QUEUE,
+ *     });
+ *
+ *     await queue.send({ userId: '123', action: 'welcome-email' });
+ *     return new Response('Queued');
+ *   },
+ *
+ *   async queue(batch, env) {
+ *     // Process messages delivered by Cloudflare
+ *     const processor = new CloudflareQueueProcessor();
+ *     await processor.processBatch(batch, async (msg) => {
+ *       console.log('Processing:', msg.body);
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class CloudflareQueueAdapter<T = unknown> implements QueueAdapter<T> {
+    readonly type: "cloudflare";
+    readonly name = "cloudflare-queue";
+    private queue;
+    constructor(config: CloudflareQueueConfig);
+    send(body: T, options?: SendMessageOptions): Promise<string>;
+    sendBatch(messages: Array<{
+        body: T;
+        options?: SendMessageOptions;
+    }>): Promise<BatchSendResult>;
+}
+/**
+ * Cloudflare Queue Processor
+ * Helper for processing queue batches in Workers queue handlers
+ *
+ * @example
+ * ```typescript
+ * export default {
+ *   async queue(batch, env) {
+ *     const processor = new CloudflareQueueProcessor<MyMessageType>();
+ *     await processor.processBatch(batch, async (msg) => {
+ *       // Process each message
+ *       await handleMessage(msg.body);
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class CloudflareQueueProcessor<T = unknown> {
+    /**
+     * Process a batch of messages from Cloudflare Queues
+     */
+    processBatch(batch: CloudflareMessageBatch<T>, handler: (message: QueueMessage<T>) => void | Promise<void>, options?: {
+        /** Whether to ack all messages at once (default: false - ack individually) */
+        ackAll?: boolean;
+        /** Whether to retry all on any failure (default: false) */
+        retryAllOnFailure?: boolean;
+    }): Promise<{
+        processed: number;
+        failed: number;
+    }>;
+    /**
+     * Convert a Cloudflare message to QueueMessage format
+     */
+    toQueueMessage(msg: CloudflareMessage<T>): QueueMessage<T>;
+}
+/**
+ * Create a Cloudflare Queue adapter
+ */
+declare function createCloudflareQueueAdapter<T = unknown>(config: CloudflareQueueConfig): CloudflareQueueAdapter<T>;
+/**
+ * Create a Cloudflare Queue processor
+ */
+declare function createCloudflareQueueProcessor<T = unknown>(): CloudflareQueueProcessor<T>;
+
+export { CloudflareQueueAdapter, CloudflareQueueProcessor, createCloudflareQueueAdapter, createCloudflareQueueProcessor };

package/dist/adapters/cloudflare.js

@@ -0,0 +1,141 @@
+// 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/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();
+}
+export {
+  CloudflareQueueAdapter,
+  CloudflareQueueProcessor,
+  createCloudflareQueueAdapter,
+  createCloudflareQueueProcessor
+};
+//# sourceMappingURL=cloudflare.js.map

package/dist/adapters/cloudflare.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types.ts","../../src/adapters/cloudflare.ts"],"sourcesContent":["/**\n * @parsrun/queue - Type Definitions\n * Queue types and interfaces\n */\n\n// Re-export types from @parsrun/types for convenience\nexport {\n  type,\n  jobStatus,\n  job,\n  jobOptions,\n  addJobRequest,\n  jobProgressUpdate,\n  queueStats as parsQueueStats,\n  queueListOptions,\n  redisQueueConfig,\n  workerOptions,\n  queueConfig,\n  type JobStatus,\n  type Job,\n  type JobOptions,\n  type AddJobRequest,\n  type JobProgressUpdate,\n  type QueueStats as ParsQueueStats,\n  type QueueListOptions,\n  type RedisQueueConfig,\n  type WorkerOptions,\n  type QueueConfig,\n} from \"@parsrun/types\";\n\n/**\n * Queue adapter type\n */\nexport type QueueAdapterType = \"memory\" | \"cloudflare\" | \"qstash\";\n\n/**\n * Message payload\n */\nexport interface QueueMessage<T = unknown> {\n  /** Unique message ID */\n  id: string;\n  /** Message payload */\n  body: T;\n  /** Message timestamp */\n  timestamp: Date;\n  /** Number of delivery attempts */\n  attempts: number;\n  /** Optional delay before processing (seconds) */\n  delaySeconds?: number | undefined;\n  /** Optional deduplication ID */\n  deduplicationId?: string | undefined;\n  /** Custom metadata */\n  metadata?: Record<string, unknown> | undefined;\n}\n\n/**\n * Send message options\n */\nexport interface SendMessageOptions {\n  /** Delay before message is available (seconds) */\n  delaySeconds?: number | undefined;\n  /** Deduplication ID (prevents duplicate processing) */\n  deduplicationId?: string | undefined;\n  /** Custom metadata */\n  metadata?: Record<string, unknown> | undefined;\n  /** Priority (higher = more important) */\n  priority?: number | undefined;\n}\n\n/**\n * Batch send result\n */\nexport interface BatchSendResult {\n  /** Total messages sent */\n  total: number;\n  /** Successfully sent */\n  successful: number;\n  /** Failed to send */\n  failed: number;\n  /** Individual message IDs */\n  messageIds: string[];\n  /** Failed messages with errors */\n  errors: Array<{ index: number; error: string }>;\n}\n\n/**\n * Message handler function\n */\nexport type MessageHandler<T = unknown> = (\n  message: QueueMessage<T>\n) => void | Promise<void>;\n\n/**\n * Consumer options\n */\nexport interface ConsumerOptions {\n  /** Maximum messages to process per batch */\n  batchSize?: number | undefined;\n  /** Visibility timeout (seconds) - how long a message is hidden while processing */\n  visibilityTimeout?: number | undefined;\n  /** Polling interval (ms) for pull-based queues */\n  pollingInterval?: number | undefined;\n  /** Maximum retries before dead-letter */\n  maxRetries?: number | undefined;\n  /** Concurrency - how many messages to process in parallel */\n  concurrency?: number | undefined;\n}\n\n/**\n * Queue adapter interface\n */\nexport interface QueueAdapter<T = unknown> {\n  /** Adapter type */\n  readonly type: QueueAdapterType;\n\n  /** Queue name */\n  readonly name: string;\n\n  /**\n   * Send a message to the queue\n   */\n  send(body: T, options?: SendMessageOptions): Promise<string>;\n\n  /**\n   * Send multiple messages at once\n   */\n  sendBatch?(messages: Array<{ body: T; options?: SendMessageOptions }>): Promise<BatchSendResult>;\n\n  /**\n   * Receive messages from the queue (pull-based)\n   * Used for manual message processing\n   */\n  receive?(maxMessages?: number, visibilityTimeout?: number): Promise<QueueMessage<T>[]>;\n\n  /**\n   * Acknowledge message processing (mark as complete)\n   */\n  ack?(messageId: string): Promise<void>;\n\n  /**\n   * Acknowledge multiple messages\n   */\n  ackBatch?(messageIds: string[]): Promise<void>;\n\n  /**\n   * Return message to queue (negative acknowledgement)\n   * Optionally with delay\n   */\n  nack?(messageId: string, delaySeconds?: number): Promise<void>;\n\n  /**\n   * Start consuming messages (push-based)\n   * For adapters that support push-based processing\n   */\n  consume?(handler: MessageHandler<T>, options?: ConsumerOptions): Promise<void>;\n\n  /**\n   * Stop consuming messages\n   */\n  stopConsuming?(): Promise<void>;\n\n  /**\n   * Get queue statistics\n   */\n  getStats?(): Promise<QueueStats>;\n\n  /**\n   * Purge all messages from queue\n   */\n  purge?(): Promise<void>;\n\n  /**\n   * Close/cleanup adapter resources\n   */\n  close?(): Promise<void>;\n}\n\n/**\n * Queue statistics\n */\nexport interface QueueStats {\n  /** Approximate number of messages in queue */\n  messageCount: number;\n  /** Messages currently being processed */\n  inFlightCount?: number | undefined;\n  /** Messages in dead-letter queue */\n  deadLetterCount?: number | undefined;\n}\n\n/**\n * Queue service configuration\n */\nexport interface QueueServiceConfig<T = unknown> {\n  /** Queue adapter to use */\n  adapter: QueueAdapter<T>;\n  /** Enable debug logging */\n  debug?: boolean | undefined;\n}\n\n/**\n * Memory queue configuration\n */\nexport interface MemoryQueueConfig {\n  /** Queue name */\n  name: string;\n  /** Maximum queue size (default: unlimited) */\n  maxSize?: number | undefined;\n  /** Default visibility timeout (seconds) */\n  visibilityTimeout?: number | undefined;\n}\n\n/**\n * Cloudflare Queue configuration\n */\nexport interface CloudflareQueueConfig {\n  /** Queue binding from environment */\n  queue: CloudflareQueue;\n}\n\n/**\n * Cloudflare Queue interface (from Workers runtime)\n */\nexport interface CloudflareQueue<T = unknown> {\n  send(message: T, options?: { delaySeconds?: number | undefined; contentType?: string | undefined }): Promise<void>;\n  sendBatch(messages: Array<{ body: T; delaySeconds?: number | undefined; contentType?: string | undefined }>): Promise<void>;\n}\n\n/**\n * Cloudflare Queue batch\n */\nexport interface CloudflareMessageBatch<T = unknown> {\n  readonly queue: string;\n  readonly messages: Array<CloudflareMessage<T>>;\n  ackAll(): void;\n  retryAll(): void;\n}\n\n/**\n * Cloudflare Queue message\n */\nexport interface CloudflareMessage<T = unknown> {\n  readonly id: string;\n  readonly timestamp: Date;\n  readonly body: T;\n  readonly attempts: number;\n  ack(): void;\n  retry(): void;\n}\n\n/**\n * QStash configuration\n */\nexport interface QStashConfig {\n  /** QStash token */\n  token: string;\n  /** Destination URL for message delivery */\n  destinationUrl: string;\n  /** Current request URL (for signature verification) */\n  currentSigningKey?: string | undefined;\n  /** Next signing key (for signature verification) */\n  nextSigningKey?: string | undefined;\n}\n\n/**\n * Queue error\n */\nexport class QueueError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly cause?: unknown\n  ) {\n    super(message);\n    this.name = \"QueueError\";\n  }\n}\n\n/**\n * Common queue error codes\n */\nexport const QueueErrorCodes = {\n  SEND_FAILED: \"SEND_FAILED\",\n  RECEIVE_FAILED: \"RECEIVE_FAILED\",\n  ACK_FAILED: \"ACK_FAILED\",\n  INVALID_CONFIG: \"INVALID_CONFIG\",\n  QUEUE_FULL: \"QUEUE_FULL\",\n  MESSAGE_NOT_FOUND: \"MESSAGE_NOT_FOUND\",\n  NOT_IMPLEMENTED: \"NOT_IMPLEMENTED\",\n} as const;\n","/**\n * @parsrun/queue - Cloudflare Queues Adapter\n * Adapter for Cloudflare Workers Queues\n */\n\nimport type {\n  BatchSendResult,\n  CloudflareMessage,\n  CloudflareMessageBatch,\n  CloudflareQueue,\n  CloudflareQueueConfig,\n  QueueAdapter,\n  QueueMessage,\n  SendMessageOptions,\n} from \"../types.js\";\nimport { QueueError, QueueErrorCodes } from \"../types.js\";\n\n/**\n * Cloudflare Queue Adapter\n * Uses Cloudflare Workers Queues for serverless message processing\n *\n * Cloudflare Queues uses a push-based model where messages are delivered\n * to queue consumers via Workers.\n *\n * @example\n * ```typescript\n * // In your Worker\n * export default {\n *   async fetch(request, env) {\n *     const queue = new CloudflareQueueAdapter({\n *       queue: env.MY_QUEUE,\n *     });\n *\n *     await queue.send({ userId: '123', action: 'welcome-email' });\n *     return new Response('Queued');\n *   },\n *\n *   async queue(batch, env) {\n *     // Process messages delivered by Cloudflare\n *     const processor = new CloudflareQueueProcessor();\n *     await processor.processBatch(batch, async (msg) => {\n *       console.log('Processing:', msg.body);\n *     });\n *   }\n * }\n * ```\n */\nexport class CloudflareQueueAdapter<T = unknown> implements QueueAdapter<T> {\n  readonly type = \"cloudflare\" as const;\n  readonly name = \"cloudflare-queue\";\n\n  private queue: CloudflareQueue<T>;\n\n  constructor(config: CloudflareQueueConfig) {\n    this.queue = config.queue as CloudflareQueue<T>;\n  }\n\n  async send(body: T, options?: SendMessageOptions): Promise<string> {\n    try {\n      await this.queue.send(body, {\n        delaySeconds: options?.delaySeconds,\n      });\n\n      // Cloudflare Queues don't return message IDs on send\n      // Generate a client-side ID for tracking\n      return `cf-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;\n    } catch (err) {\n      throw new QueueError(\n        `Cloudflare Queue send failed: ${err instanceof Error ? err.message : \"Unknown error\"}`,\n        QueueErrorCodes.SEND_FAILED,\n        err\n      );\n    }\n  }\n\n  async sendBatch(\n    messages: Array<{ body: T; options?: SendMessageOptions }>\n  ): Promise<BatchSendResult> {\n    try {\n      const batchMessages = messages.map((m) => ({\n        body: m.body,\n        delaySeconds: m.options?.delaySeconds,\n      }));\n\n      await this.queue.sendBatch(batchMessages);\n\n      // Generate client-side IDs\n      const messageIds = messages.map(\n        () => `cf-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`\n      );\n\n      return {\n        total: messages.length,\n        successful: messages.length,\n        failed: 0,\n        messageIds,\n        errors: [],\n      };\n    } catch (err) {\n      throw new QueueError(\n        `Cloudflare Queue batch send failed: ${err instanceof Error ? err.message : \"Unknown error\"}`,\n        QueueErrorCodes.SEND_FAILED,\n        err\n      );\n    }\n  }\n\n  // Cloudflare Queues are push-based, so receive is not applicable\n  // Messages are delivered to queue handlers via Workers\n}\n\n/**\n * Cloudflare Queue Processor\n * Helper for processing queue batches in Workers queue handlers\n *\n * @example\n * ```typescript\n * export default {\n *   async queue(batch, env) {\n *     const processor = new CloudflareQueueProcessor<MyMessageType>();\n *     await processor.processBatch(batch, async (msg) => {\n *       // Process each message\n *       await handleMessage(msg.body);\n *     });\n *   }\n * }\n * ```\n */\nexport class CloudflareQueueProcessor<T = unknown> {\n  /**\n   * Process a batch of messages from Cloudflare Queues\n   */\n  async processBatch(\n    batch: CloudflareMessageBatch<T>,\n    handler: (message: QueueMessage<T>) => void | Promise<void>,\n    options?: {\n      /** Whether to ack all messages at once (default: false - ack individually) */\n      ackAll?: boolean;\n      /** Whether to retry all on any failure (default: false) */\n      retryAllOnFailure?: boolean;\n    }\n  ): Promise<{ processed: number; failed: number }> {\n    let processed = 0;\n    let failed = 0;\n\n    for (const msg of batch.messages) {\n      try {\n        const queueMessage: QueueMessage<T> = {\n          id: msg.id,\n          body: msg.body,\n          timestamp: msg.timestamp,\n          attempts: msg.attempts,\n        };\n\n        await handler(queueMessage);\n\n        if (!options?.ackAll) {\n          msg.ack();\n        }\n        processed++;\n      } catch (err) {\n        failed++;\n\n        if (options?.retryAllOnFailure) {\n          batch.retryAll();\n          return { processed, failed: batch.messages.length };\n        }\n\n        // Retry individual message\n        msg.retry();\n      }\n    }\n\n    if (options?.ackAll && failed === 0) {\n      batch.ackAll();\n    }\n\n    return { processed, failed };\n  }\n\n  /**\n   * Convert a Cloudflare message to QueueMessage format\n   */\n  toQueueMessage(msg: CloudflareMessage<T>): QueueMessage<T> {\n    return {\n      id: msg.id,\n      body: msg.body,\n      timestamp: msg.timestamp,\n      attempts: msg.attempts,\n    };\n  }\n}\n\n/**\n * Create a Cloudflare Queue adapter\n */\nexport function createCloudflareQueueAdapter<T = unknown>(\n  config: CloudflareQueueConfig\n): CloudflareQueueAdapter<T> {\n  return new CloudflareQueueAdapter<T>(config);\n}\n\n/**\n * Create a Cloudflare Queue processor\n */\nexport function createCloudflareQueueProcessor<T = unknown>(): CloudflareQueueProcessor<T> {\n  return new CloudflareQueueProcessor<T>();\n}\n"],"mappings":"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","names":[]}

package/dist/adapters/index.d.ts

@@ -0,0 +1,5 @@
+export { MemoryQueueAdapter, createMemoryQueueAdapter } from './memory.js';
+export { CloudflareQueueAdapter, CloudflareQueueProcessor, createCloudflareQueueAdapter, createCloudflareQueueProcessor } from './cloudflare.js';
+export { QStashAdapter, QStashReceiver, createQStashAdapter, createQStashReceiver } from './qstash.js';
+import '../types.js';
+import '@parsrun/types';