@gravito/stream 1.0.0-alpha.5 → 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,1412 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/drivers/DatabaseDriver.ts
+var DatabaseDriver_exports = {};
+__export(DatabaseDriver_exports, {
+  DatabaseDriver: () => DatabaseDriver
+});
+var DatabaseDriver;
+var init_DatabaseDriver = __esm({
+  "src/drivers/DatabaseDriver.ts"() {
+    "use strict";
+    DatabaseDriver = class {
+      tableName;
+      dbService;
+      constructor(config) {
+        this.tableName = config.table ?? "jobs";
+        this.dbService = config.dbService;
+        if (!this.dbService) {
+          throw new Error(
+            "[DatabaseDriver] dbService is required. Please provide a database service that implements DatabaseService interface."
+          );
+        }
+      }
+      /**
+       * Push a job to a queue.
+       */
+      async push(queue, job) {
+        const availableAt = job.delaySeconds ? new Date(Date.now() + job.delaySeconds * 1e3) : /* @__PURE__ */ new Date();
+        await this.dbService.execute(
+          `INSERT INTO ${this.tableName} (queue, payload, attempts, available_at, created_at)
+       VALUES ($1, $2, $3, $4, $5)`,
+          [queue, job.data, job.attempts ?? 0, availableAt.toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
+        );
+      }
+      /**
+       * Pop a job from the queue (FIFO, with delay support).
+       */
+      async pop(queue) {
+        const result = await this.dbService.execute(
+          `SELECT id, payload, attempts, created_at, available_at
+       FROM ${this.tableName}
+       WHERE queue = $1
+         AND available_at <= NOW()
+         AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '5 minutes')
+       ORDER BY created_at ASC
+       LIMIT 1
+       FOR UPDATE SKIP LOCKED`,
+          [queue]
+        ).catch(() => {
+          return this.dbService.execute(
+            `SELECT id, payload, attempts, created_at, available_at
+         FROM ${this.tableName}
+         WHERE queue = $1
+           AND available_at <= NOW()
+           AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '5 minutes')
+         ORDER BY created_at ASC
+         LIMIT 1
+         FOR UPDATE`,
+            [queue]
+          );
+        });
+        const rows = result;
+        if (!rows || rows.length === 0) {
+          return null;
+        }
+        const row = rows[0];
+        await this.dbService.execute(
+          `UPDATE ${this.tableName}
+       SET reserved_at = NOW()
+       WHERE id = $1`,
+          [row.id]
+        );
+        const createdAt = new Date(row.created_at).getTime();
+        const delaySeconds = row.available_at ? Math.max(0, Math.floor((new Date(row.available_at).getTime() - createdAt) / 1e3)) : void 0;
+        return {
+          id: row.id,
+          type: "class",
+          // Default; should be inferred from payload in a full implementation
+          data: row.payload,
+          createdAt,
+          attempts: row.attempts,
+          ...delaySeconds !== void 0 ? { delaySeconds } : {}
+        };
+      }
+      /**
+       * Get queue size.
+       */
+      async size(queue) {
+        const result = await this.dbService.execute(
+          `SELECT COUNT(*) as count
+       FROM ${this.tableName}
+       WHERE queue = $1
+         AND available_at <= NOW()
+         AND (reserved_at IS NULL OR reserved_at < NOW() - INTERVAL '5 minutes')`,
+          [queue]
+        );
+        return result?.[0]?.count ?? 0;
+      }
+      /**
+       * Clear a queue.
+       */
+      async clear(queue) {
+        await this.dbService.execute(`DELETE FROM ${this.tableName} WHERE queue = $1`, [queue]);
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        await this.dbService.transaction(async (tx) => {
+          for (const job of jobs) {
+            const availableAt = job.delaySeconds ? new Date(Date.now() + job.delaySeconds * 1e3) : /* @__PURE__ */ new Date();
+            await tx.execute(
+              `INSERT INTO ${this.tableName} (queue, payload, attempts, available_at, created_at)
+           VALUES ($1, $2, $3, $4, $5)`,
+              [queue, job.data, job.attempts ?? 0, availableAt.toISOString(), (/* @__PURE__ */ new Date()).toISOString()]
+            );
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/drivers/KafkaDriver.ts
+var KafkaDriver_exports = {};
+__export(KafkaDriver_exports, {
+  KafkaDriver: () => KafkaDriver
+});
+var KafkaDriver;
+var init_KafkaDriver = __esm({
+  "src/drivers/KafkaDriver.ts"() {
+    "use strict";
+    KafkaDriver = class {
+      client;
+      consumerGroupId;
+      producer;
+      admin;
+      constructor(config) {
+        this.client = config.client;
+        this.consumerGroupId = config.consumerGroupId ?? "gravito-workers";
+        if (!this.client) {
+          throw new Error("[KafkaDriver] Kafka client is required. Please install kafkajs package.");
+        }
+      }
+      /**
+       * Ensure the producer is connected.
+       */
+      async ensureProducer() {
+        if (!this.producer) {
+          this.producer = this.client.producer();
+          await this.producer.connect();
+        }
+        return this.producer;
+      }
+      /**
+       * Ensure the admin client is connected.
+       */
+      async ensureAdmin() {
+        if (!this.admin) {
+          this.admin = this.client.admin();
+          await this.admin.connect();
+        }
+        return this.admin;
+      }
+      /**
+       * Push a job to a topic.
+       */
+      async push(queue, job) {
+        const producer = await this.ensureProducer();
+        const payload = JSON.stringify({
+          id: job.id,
+          type: job.type,
+          data: job.data,
+          className: job.className,
+          createdAt: job.createdAt,
+          delaySeconds: job.delaySeconds,
+          attempts: job.attempts,
+          maxAttempts: job.maxAttempts
+        });
+        await producer.send({
+          topic: queue,
+          messages: [
+            {
+              key: job.id,
+              value: payload
+            }
+          ]
+        });
+      }
+      /**
+       * Pop is not supported for Kafka.
+       *
+       * Note: Kafka uses a push-based model, so you should use `subscribe()`.
+       */
+      async pop(_queue) {
+        throw new Error("[KafkaDriver] Kafka uses push-based model. Use subscribe() instead of pop().");
+      }
+      /**
+       * Kafka does not provide a direct queue size.
+       *
+       * Returns 0; use Kafka tooling/metrics for lag/size insights.
+       */
+      async size(_queue) {
+        return 0;
+      }
+      /**
+       * Clear a queue by deleting the topic.
+       */
+      async clear(queue) {
+        const admin = await this.ensureAdmin();
+        await admin.deleteTopics({ topics: [queue] });
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        const producer = await this.ensureProducer();
+        const messages = jobs.map((job) => {
+          const payload = JSON.stringify({
+            id: job.id,
+            type: job.type,
+            data: job.data,
+            className: job.className,
+            createdAt: job.createdAt,
+            delaySeconds: job.delaySeconds,
+            attempts: job.attempts,
+            maxAttempts: job.maxAttempts
+          });
+          return {
+            key: job.id,
+            value: payload
+          };
+        });
+        await producer.send({
+          topic: queue,
+          messages
+        });
+      }
+      /**
+       * Create a topic.
+       */
+      async createTopic(topic, options) {
+        const admin = await this.ensureAdmin();
+        await admin.createTopics({
+          topics: [
+            {
+              topic,
+              numPartitions: options?.partitions ?? 1,
+              replicationFactor: options?.replicationFactor ?? 1
+            }
+          ]
+        });
+      }
+      /**
+       * Delete a topic.
+       */
+      async deleteTopic(topic) {
+        await this.clear(topic);
+      }
+      /**
+       * Subscribe to a topic (push-based model).
+       */
+      async subscribe(queue, callback) {
+        const consumer = this.client.consumer({ groupId: this.consumerGroupId });
+        await consumer.connect();
+        await consumer.subscribe({ topics: [queue] });
+        await consumer.run({
+          eachMessage: async ({ message }) => {
+            if (!message.value) {
+              return;
+            }
+            const payload = JSON.parse(message.value.toString());
+            const job = {
+              id: payload.id,
+              type: payload.type,
+              data: payload.data,
+              className: payload.className,
+              createdAt: payload.createdAt,
+              delaySeconds: payload.delaySeconds,
+              attempts: payload.attempts,
+              maxAttempts: payload.maxAttempts
+            };
+            try {
+              await callback(job);
+            } catch (error) {
+              console.error("[KafkaDriver] Error processing message:", error);
+            }
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/drivers/RedisDriver.ts
+var RedisDriver_exports = {};
+__export(RedisDriver_exports, {
+  RedisDriver: () => RedisDriver
+});
+var RedisDriver;
+var init_RedisDriver = __esm({
+  "src/drivers/RedisDriver.ts"() {
+    "use strict";
+    RedisDriver = class {
+      prefix;
+      client;
+      constructor(config) {
+        this.client = config.client;
+        this.prefix = config.prefix ?? "queue:";
+        if (!this.client) {
+          throw new Error(
+            "[RedisDriver] Redis client is required. Please install ioredis or redis package."
+          );
+        }
+      }
+      /**
+       * Get full Redis key for a queue.
+       */
+      getKey(queue) {
+        return `${this.prefix}${queue}`;
+      }
+      /**
+       * Push a job (LPUSH).
+       */
+      async push(queue, job) {
+        const key = this.getKey(queue);
+        const payload = JSON.stringify({
+          id: job.id,
+          type: job.type,
+          data: job.data,
+          className: job.className,
+          createdAt: job.createdAt,
+          delaySeconds: job.delaySeconds,
+          attempts: job.attempts,
+          maxAttempts: job.maxAttempts
+        });
+        if (job.delaySeconds && job.delaySeconds > 0) {
+          const delayKey = `${key}:delayed`;
+          const score = Date.now() + job.delaySeconds * 1e3;
+          if (typeof this.client.zadd === "function") {
+            await this.client.zadd(delayKey, score, payload);
+          } else {
+            await this.client.lpush(key, payload);
+          }
+        } else {
+          await this.client.lpush(key, payload);
+        }
+      }
+      /**
+       * Pop a job (RPOP, FIFO).
+       */
+      async pop(queue) {
+        const key = this.getKey(queue);
+        const delayKey = `${key}:delayed`;
+        if (typeof this.client.zrange === "function") {
+          const now = Date.now();
+          const delayedJobs = await this.client.zrange(delayKey, 0, 0, true);
+          if (delayedJobs && delayedJobs.length >= 2) {
+            const score = parseFloat(delayedJobs[1]);
+            if (score <= now) {
+              const payload2 = delayedJobs[0];
+              await this.client.zrem(delayKey, payload2);
+              return this.parsePayload(payload2);
+            }
+          }
+        }
+        const payload = await this.client.rpop(key);
+        if (!payload) {
+          return null;
+        }
+        return this.parsePayload(payload);
+      }
+      /**
+       * Parse Redis payload.
+       */
+      parsePayload(payload) {
+        const parsed = JSON.parse(payload);
+        return {
+          id: parsed.id,
+          type: parsed.type,
+          data: parsed.data,
+          className: parsed.className,
+          createdAt: parsed.createdAt,
+          delaySeconds: parsed.delaySeconds,
+          attempts: parsed.attempts,
+          maxAttempts: parsed.maxAttempts
+        };
+      }
+      /**
+       * Get queue size.
+       */
+      async size(queue) {
+        const key = this.getKey(queue);
+        return this.client.llen(key);
+      }
+      /**
+       * Clear a queue.
+       */
+      async clear(queue) {
+        const key = this.getKey(queue);
+        const delayKey = `${key}:delayed`;
+        await this.client.del(key);
+        if (typeof this.client.del === "function") {
+          await this.client.del(delayKey);
+        }
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        const key = this.getKey(queue);
+        const payloads = jobs.map(
+          (job) => JSON.stringify({
+            id: job.id,
+            type: job.type,
+            data: job.data,
+            className: job.className,
+            createdAt: job.createdAt,
+            delaySeconds: job.delaySeconds,
+            attempts: job.attempts,
+            maxAttempts: job.maxAttempts
+          })
+        );
+        await this.client.lpush(key, ...payloads);
+      }
+      /**
+       * Pop multiple jobs.
+       */
+      async popMany(queue, count) {
+        const key = this.getKey(queue);
+        const results = [];
+        for (let i = 0; i < count; i++) {
+          const payload = await this.client.rpop(key);
+          if (payload) {
+            results.push(this.parsePayload(payload));
+          } else {
+            break;
+          }
+        }
+        return results;
+      }
+    };
+  }
+});
+
+// src/drivers/SQSDriver.ts
+var SQSDriver_exports = {};
+__export(SQSDriver_exports, {
+  SQSDriver: () => SQSDriver
+});
+var SQSDriver;
+var init_SQSDriver = __esm({
+  "src/drivers/SQSDriver.ts"() {
+    "use strict";
+    SQSDriver = class {
+      client;
+      queueUrlPrefix;
+      visibilityTimeout;
+      waitTimeSeconds;
+      queueUrls = /* @__PURE__ */ new Map();
+      constructor(config) {
+        this.client = config.client;
+        this.queueUrlPrefix = config.queueUrlPrefix ?? "";
+        this.visibilityTimeout = config.visibilityTimeout ?? 30;
+        this.waitTimeSeconds = config.waitTimeSeconds ?? 20;
+        if (!this.client) {
+          throw new Error(
+            "[SQSDriver] SQS client is required. Please install @aws-sdk/client-sqs package."
+          );
+        }
+      }
+      /**
+       * Resolve the full queue URL.
+       */
+      async getQueueUrl(queue) {
+        if (this.queueUrls.has(queue)) {
+          return this.queueUrls.get(queue);
+        }
+        if (this.queueUrlPrefix) {
+          const url = `${this.queueUrlPrefix}/${queue}`;
+          this.queueUrls.set(queue, url);
+          return url;
+        }
+        this.queueUrls.set(queue, queue);
+        return queue;
+      }
+      /**
+       * Push a job to SQS.
+       */
+      async push(queue, job) {
+        const { SendMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const payload = JSON.stringify({
+          id: job.id,
+          type: job.type,
+          data: job.data,
+          className: job.className,
+          createdAt: job.createdAt,
+          delaySeconds: job.delaySeconds,
+          attempts: job.attempts,
+          maxAttempts: job.maxAttempts
+        });
+        const delaySeconds = job.delaySeconds ? Math.min(job.delaySeconds, 900) : 0;
+        await this.client.send(
+          new SendMessageCommand({
+            QueueUrl: queueUrl,
+            MessageBody: payload,
+            DelaySeconds: delaySeconds
+          })
+        );
+      }
+      /**
+       * Pop a job (long polling).
+       */
+      async pop(queue) {
+        const { ReceiveMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const response = await this.client.send(
+          new ReceiveMessageCommand({
+            QueueUrl: queueUrl,
+            MaxNumberOfMessages: 1,
+            WaitTimeSeconds: this.waitTimeSeconds,
+            VisibilityTimeout: this.visibilityTimeout
+          })
+        );
+        if (!response.Messages || response.Messages.length === 0) {
+          return null;
+        }
+        const message = response.Messages[0];
+        const payload = JSON.parse(message.Body ?? "{}");
+        return {
+          id: payload.id ?? message.MessageId,
+          type: payload.type,
+          data: payload.data,
+          className: payload.className,
+          createdAt: payload.createdAt,
+          delaySeconds: payload.delaySeconds,
+          attempts: payload.attempts,
+          maxAttempts: payload.maxAttempts,
+          // Store ReceiptHandle for acknowledgement
+          ...message.ReceiptHandle && { receiptHandle: message.ReceiptHandle }
+        };
+      }
+      /**
+       * Get queue size (approximate).
+       */
+      async size(queue) {
+        const { GetQueueAttributesCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        try {
+          const response = await this.client.send(
+            new GetQueueAttributesCommand({
+              QueueUrl: queueUrl,
+              AttributeNames: ["ApproximateNumberOfMessages"]
+            })
+          );
+          return parseInt(response.Attributes?.ApproximateNumberOfMessages ?? "0", 10);
+        } catch (error) {
+          console.error("[SQSDriver] Error getting queue size:", error);
+          return 0;
+        }
+      }
+      /**
+       * Clear a queue by receiving and deleting messages.
+       *
+       * Note: SQS does not provide a direct "purge" API via this wrapper. This method will
+       * keep receiving and deleting messages until the queue is empty.
+       */
+      async clear(queue) {
+        const { DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        while (true) {
+          const job = await this.pop(queue);
+          if (!job) {
+            break;
+          }
+          if (job.receiptHandle) {
+            await this.client.send(
+              new DeleteMessageCommand({
+                QueueUrl: queueUrl,
+                ReceiptHandle: job.receiptHandle
+              })
+            );
+          }
+        }
+      }
+      /**
+       * Push multiple jobs.
+       */
+      async pushMany(queue, jobs) {
+        if (jobs.length === 0) {
+          return;
+        }
+        const { SendMessageBatchCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        const batchSize = 10;
+        for (let i = 0; i < jobs.length; i += batchSize) {
+          const batch = jobs.slice(i, i + batchSize);
+          const entries = batch.map((job, index) => {
+            const payload = JSON.stringify({
+              id: job.id,
+              type: job.type,
+              data: job.data,
+              className: job.className,
+              createdAt: job.createdAt,
+              delaySeconds: job.delaySeconds,
+              attempts: job.attempts,
+              maxAttempts: job.maxAttempts
+            });
+            return {
+              Id: `${job.id}-${index}`,
+              MessageBody: payload,
+              DelaySeconds: job.delaySeconds ? Math.min(job.delaySeconds, 900) : 0
+            };
+          });
+          await this.client.send(
+            new SendMessageBatchCommand({
+              QueueUrl: queueUrl,
+              Entries: entries
+            })
+          );
+        }
+      }
+      /**
+       * Acknowledge is not supported via messageId.
+       */
+      async acknowledge(_messageId) {
+        throw new Error("[SQSDriver] Use deleteMessage() with ReceiptHandle instead of acknowledge().");
+      }
+      /**
+       * Delete a message (acknowledge processing completion).
+       */
+      async deleteMessage(queue, receiptHandle) {
+        const { DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+        const queueUrl = await this.getQueueUrl(queue);
+        await this.client.send(
+          new DeleteMessageCommand({
+            QueueUrl: queueUrl,
+            ReceiptHandle: receiptHandle
+          })
+        );
+      }
+    };
+  }
+});
+
+// src/Worker.ts
+var Worker = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Process a Job.
+   * @param job - Job instance
+   */
+  async process(job) {
+    const maxAttempts = this.options.maxAttempts ?? 3;
+    const timeout = this.options.timeout;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        job.attempts = attempt;
+        job.maxAttempts = maxAttempts;
+        if (timeout) {
+          await Promise.race([
+            job.handle(),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new Error(`Job timeout after ${timeout} seconds`)),
+                timeout * 1e3
+              )
+            )
+          ]);
+        } else {
+          await job.handle();
+        }
+        return;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt === maxAttempts) {
+          await this.handleFailure(job, lastError);
+          throw lastError;
+        }
+        const delay = Math.min(1e3 * 2 ** (attempt - 1), 3e4);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  /**
+   * Handle failure.
+   */
+  async handleFailure(job, error) {
+    try {
+      await job.failed(error);
+    } catch (failedError) {
+      console.error("[Worker] Error in job.failed():", failedError);
+    }
+    if (this.options.onFailed) {
+      try {
+        await this.options.onFailed(job, error);
+      } catch (callbackError) {
+        console.error("[Worker] Error in onFailed callback:", callbackError);
+      }
+    }
+  }
+};
+
+// src/Consumer.ts
+var Consumer = class {
+  constructor(queueManager, options) {
+    this.queueManager = queueManager;
+    this.options = options;
+  }
+  running = false;
+  stopRequested = false;
+  /**
+   * Start the consumer loop.
+   */
+  async start() {
+    if (this.running) {
+      throw new Error("Consumer is already running");
+    }
+    this.running = true;
+    this.stopRequested = false;
+    const worker = new Worker(this.options.workerOptions);
+    const pollInterval = this.options.pollInterval ?? 1e3;
+    const keepAlive = this.options.keepAlive ?? true;
+    console.log("[Consumer] Started", {
+      queues: this.options.queues,
+      connection: this.options.connection
+    });
+    while (this.running && !this.stopRequested) {
+      let processed = false;
+      for (const queue of this.options.queues) {
+        try {
+          const job = await this.queueManager.pop(queue, this.options.connection);
+          if (job) {
+            processed = true;
+            await worker.process(job).catch((error) => {
+              console.error(`[Consumer] Error processing job in queue "${queue}":`, error);
+            });
+          }
+        } catch (error) {
+          console.error(`[Consumer] Error polling queue "${queue}":`, error);
+        }
+      }
+      if (!processed && !keepAlive) {
+        break;
+      }
+      if (!this.stopRequested) {
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+    }
+    this.running = false;
+    console.log("[Consumer] Stopped");
+  }
+  /**
+   * Stop the consumer loop (graceful shutdown).
+   */
+  async stop() {
+    console.log("[Consumer] Stopping...");
+    this.stopRequested = true;
+    while (this.running) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  /**
+   * Check whether the consumer is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+
+// src/index.ts
+init_DatabaseDriver();
+init_KafkaDriver();
+
+// src/drivers/MemoryDriver.ts
+var MemoryDriver = class {
+  queues = /* @__PURE__ */ new Map();
+  /**
+   * Push a job to a queue.
+   */
+  async push(queue, job) {
+    if (!this.queues.has(queue)) {
+      this.queues.set(queue, []);
+    }
+    this.queues.get(queue)?.push(job);
+  }
+  /**
+   * Pop a job from a queue (FIFO).
+   */
+  async pop(queue) {
+    const queueJobs = this.queues.get(queue);
+    if (!queueJobs || queueJobs.length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    const availableIndex = queueJobs.findIndex(
+      (job) => !job.delaySeconds || now >= job.createdAt + job.delaySeconds * 1e3
+    );
+    if (availableIndex === -1) {
+      return null;
+    }
+    return queueJobs.splice(availableIndex, 1)[0];
+  }
+  /**
+   * Get queue size.
+   */
+  async size(queue) {
+    return this.queues.get(queue)?.length ?? 0;
+  }
+  /**
+   * Clear a queue.
+   */
+  async clear(queue) {
+    this.queues.delete(queue);
+  }
+  /**
+   * Push multiple jobs.
+   */
+  async pushMany(queue, jobs) {
+    if (!this.queues.has(queue)) {
+      this.queues.set(queue, []);
+    }
+    this.queues.get(queue)?.push(...jobs);
+  }
+  /**
+   * Pop multiple jobs.
+   */
+  async popMany(queue, count) {
+    const results = [];
+    for (let i = 0; i < count; i++) {
+      const job = await this.pop(queue);
+      if (job) {
+        results.push(job);
+      } else {
+        break;
+      }
+    }
+    return results;
+  }
+};
+
+// src/index.ts
+init_RedisDriver();
+init_SQSDriver();
+
+// src/Job.ts
+var Job = class {
+  /**
+   * Queue name.
+   */
+  queueName;
+  /**
+   * Connection name.
+   */
+  connectionName;
+  /**
+   * Delay before execution (seconds).
+   */
+  delaySeconds;
+  /**
+   * Current attempt number.
+   */
+  attempts;
+  /**
+   * Maximum attempts.
+   */
+  maxAttempts;
+  /**
+   * Set target queue.
+   */
+  onQueue(queue) {
+    this.queueName = queue;
+    return this;
+  }
+  /**
+   * Set target connection.
+   */
+  onConnection(connection) {
+    this.connectionName = connection;
+    return this;
+  }
+  /**
+   * Set delay (seconds).
+   */
+  delay(delay) {
+    this.delaySeconds = delay;
+    return this;
+  }
+  /**
+   * Failure handler (optional).
+   *
+   * Called when the job fails and reaches the maximum number of attempts.
+   * Subclasses can override to implement custom failure handling.
+   *
+   * @param error - Error instance
+   */
+  async failed(_error) {
+  }
+};
+
+// src/serializers/ClassNameSerializer.ts
+var ClassNameSerializer = class {
+  /**
+   * Job class registry (for resolving classes by name).
+   */
+  jobClasses = /* @__PURE__ */ new Map();
+  /**
+   * Register a Job class.
+   * @param jobClass - Job class
+   */
+  register(jobClass) {
+    this.jobClasses.set(jobClass.name, jobClass);
+  }
+  /**
+   * Register multiple Job classes.
+   * @param jobClasses - Job class array
+   */
+  registerMany(jobClasses) {
+    for (const jobClass of jobClasses) {
+      this.register(jobClass);
+    }
+  }
+  /**
+   * Serialize a Job.
+   */
+  serialize(job) {
+    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    const className = job.constructor.name;
+    const properties = {};
+    for (const key in job) {
+      if (Object.hasOwn(job, key) && typeof job[key] !== "function") {
+        properties[key] = job[key];
+      }
+    }
+    return {
+      id,
+      type: "class",
+      className,
+      data: JSON.stringify({
+        class: className,
+        properties
+      }),
+      createdAt: Date.now(),
+      ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
+      attempts: job.attempts ?? 0,
+      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {}
+    };
+  }
+  /**
+   * Deserialize a Job.
+   */
+  deserialize(serialized) {
+    if (serialized.type !== "class") {
+      throw new Error('Invalid serialization type: expected "class"');
+    }
+    if (!serialized.className) {
+      throw new Error("Missing className in serialized job");
+    }
+    const JobClass = this.jobClasses.get(serialized.className);
+    if (!JobClass) {
+      throw new Error(
+        `Job class "${serialized.className}" is not registered. Please register it using serializer.register().`
+      );
+    }
+    const parsed = JSON.parse(serialized.data);
+    const job = new JobClass();
+    if (parsed.properties) {
+      Object.assign(job, parsed.properties);
+    }
+    if (serialized.delaySeconds !== void 0) {
+      job.delaySeconds = serialized.delaySeconds;
+    }
+    if (serialized.attempts !== void 0) {
+      job.attempts = serialized.attempts;
+    }
+    if (serialized.maxAttempts !== void 0) {
+      job.maxAttempts = serialized.maxAttempts;
+    }
+    return job;
+  }
+};
+
+// src/serializers/JsonSerializer.ts
+var JsonSerializer = class {
+  /**
+   * Serialize a job.
+   */
+  serialize(job) {
+    const id = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    return {
+      id,
+      type: "json",
+      data: JSON.stringify({
+        job: job.constructor.name,
+        properties: { ...job }
+      }),
+      createdAt: Date.now(),
+      ...job.delaySeconds !== void 0 ? { delaySeconds: job.delaySeconds } : {},
+      attempts: job.attempts ?? 0,
+      ...job.maxAttempts !== void 0 ? { maxAttempts: job.maxAttempts } : {}
+    };
+  }
+  /**
+   * Deserialize a job.
+   *
+   * Note: this implementation only restores properties and does not recreate class instances.
+   * For class instances, use `ClassNameSerializer`.
+   */
+  deserialize(serialized) {
+    if (serialized.type !== "json") {
+      throw new Error('Invalid serialization type: expected "json"');
+    }
+    const parsed = JSON.parse(serialized.data);
+    const job = /* @__PURE__ */ Object.create({});
+    Object.assign(job, parsed.properties);
+    return job;
+  }
+};
+
+// src/QueueManager.ts
+var QueueManager = class {
+  drivers = /* @__PURE__ */ new Map();
+  serializers = /* @__PURE__ */ new Map();
+  defaultConnection;
+  defaultSerializer;
+  constructor(config = {}) {
+    this.defaultConnection = config.default ?? "default";
+    const serializerType = config.defaultSerializer ?? "class";
+    if (serializerType === "class") {
+      this.defaultSerializer = new ClassNameSerializer();
+    } else {
+      this.defaultSerializer = new JsonSerializer();
+    }
+    if (!this.drivers.has("default")) {
+      this.drivers.set("default", new MemoryDriver());
+    }
+    if (config.connections) {
+      for (const [name, connectionConfig] of Object.entries(config.connections)) {
+        this.registerConnection(name, connectionConfig);
+      }
+    }
+  }
+  /**
+   * Register a connection.
+   * @param name - Connection name
+   * @param config - Connection config
+   */
+  registerConnection(name, config) {
+    const driverType = config.driver;
+    switch (driverType) {
+      case "memory":
+        this.drivers.set(name, new MemoryDriver());
+        break;
+      case "database": {
+        const { DatabaseDriver: DatabaseDriver2 } = (init_DatabaseDriver(), __toCommonJS(DatabaseDriver_exports));
+        const dbService = config.dbService;
+        if (!dbService) {
+          throw new Error(
+            "[QueueManager] DatabaseDriver requires dbService. Please provide a database service that implements DatabaseService interface."
+          );
+        }
+        this.drivers.set(
+          name,
+          new DatabaseDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            dbService,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            table: config.table
+          })
+        );
+        break;
+      }
+      case "redis": {
+        const { RedisDriver: RedisDriver2 } = (init_RedisDriver(), __toCommonJS(RedisDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] RedisDriver requires client. Please provide Redis client in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new RedisDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            prefix: config.prefix
+          })
+        );
+        break;
+      }
+      case "kafka": {
+        const { KafkaDriver: KafkaDriver2 } = (init_KafkaDriver(), __toCommonJS(KafkaDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] KafkaDriver requires client. Please provide Kafka client in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new KafkaDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            consumerGroupId: config.consumerGroupId
+          })
+        );
+        break;
+      }
+      case "sqs": {
+        const { SQSDriver: SQSDriver2 } = (init_SQSDriver(), __toCommonJS(SQSDriver_exports));
+        const client = config.client;
+        if (!client) {
+          throw new Error(
+            "[QueueManager] SQSDriver requires client. Please provide SQS client in connection config."
+          );
+        }
+        this.drivers.set(
+          name,
+          new SQSDriver2({
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver loading requires type assertion
+            client,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            queueUrlPrefix: config.queueUrlPrefix,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            visibilityTimeout: config.visibilityTimeout,
+            // biome-ignore lint/suspicious/noExplicitAny: Dynamic driver config type
+            waitTimeSeconds: config.waitTimeSeconds
+          })
+        );
+        break;
+      }
+      default:
+        throw new Error(
+          `Driver "${driverType}" is not supported. Supported drivers: memory, database, redis, kafka, sqs`
+        );
+    }
+  }
+  /**
+   * Get a driver for a connection.
+   * @param connection - Connection name
+   * @returns Driver instance
+   */
+  getDriver(connection) {
+    const driver = this.drivers.get(connection);
+    if (!driver) {
+      throw new Error(`Connection "${connection}" not found`);
+    }
+    return driver;
+  }
+  /**
+   * Get a serializer.
+   * @param type - Serializer type
+   * @returns Serializer instance
+   */
+  getSerializer(type) {
+    if (type) {
+      const serializer = this.serializers.get(type);
+      if (!serializer) {
+        throw new Error(`Serializer "${type}" not found`);
+      }
+      return serializer;
+    }
+    return this.defaultSerializer;
+  }
+  /**
+   * Register Job classes (used by ClassNameSerializer).
+   * @param jobClasses - Job class array
+   */
+  registerJobClasses(jobClasses) {
+    if (this.defaultSerializer instanceof ClassNameSerializer) {
+      this.defaultSerializer.registerMany(jobClasses);
+    }
+  }
+  /**
+   * Push a Job to the queue.
+   *
+   * @template T - The type of the job.
+   * @param job - Job instance to push.
+   * @returns The same job instance (for fluent chaining).
+   *
+   * @example
+   * ```typescript
+   * await manager.push(new SendEmailJob('user@example.com'));
+   * ```
+   */
+  async push(job) {
+    const connection = job.connectionName ?? this.defaultConnection;
+    const queue = job.queueName ?? "default";
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    const serialized = serializer.serialize(job);
+    await driver.push(queue, serialized);
+    return job;
+  }
+  /**
+   * Push multiple jobs to the queue.
+   *
+   * @template T - The type of the jobs.
+   * @param jobs - Array of job instances.
+   *
+   * @example
+   * ```typescript
+   * await manager.pushMany([new JobA(), new JobB()]);
+   * ```
+   */
+  async pushMany(jobs) {
+    if (jobs.length === 0) {
+      return;
+    }
+    const groups = /* @__PURE__ */ new Map();
+    const serializer = this.getSerializer();
+    for (const job of jobs) {
+      const connection = job.connectionName ?? this.defaultConnection;
+      const queue = job.queueName ?? "default";
+      const key = `${connection}:${queue}`;
+      const serialized = serializer.serialize(job);
+      if (!groups.has(key)) {
+        groups.set(key, []);
+      }
+      groups.get(key)?.push(serialized);
+    }
+    for (const [key, serializedJobs] of groups.entries()) {
+      const [connection, queue] = key.split(":");
+      if (!connection || !queue) {
+        continue;
+      }
+      const driver = this.getDriver(connection);
+      if (driver.pushMany) {
+        await driver.pushMany(queue, serializedJobs);
+      } else {
+        for (const job of serializedJobs) {
+          await driver.push(queue, job);
+        }
+      }
+    }
+  }
+  /**
+   * Pop a job from the queue.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   * @returns Job instance or null if queue is empty.
+   *
+   * @example
+   * ```typescript
+   * const job = await manager.pop('emails');
+   * if (job) await job.handle();
+   * ```
+   */
+  async pop(queue = "default", connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    const serializer = this.getSerializer();
+    const serialized = await driver.pop(queue);
+    if (!serialized) {
+      return null;
+    }
+    try {
+      return serializer.deserialize(serialized);
+    } catch (error) {
+      console.error("[QueueManager] Failed to deserialize job:", error);
+      return null;
+    }
+  }
+  /**
+   * Get queue size.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   * @returns Number of jobs in the queue.
+   */
+  async size(queue = "default", connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    return driver.size(queue);
+  }
+  /**
+   * Clear all jobs from a queue.
+   *
+   * @param queue - Queue name (default: 'default').
+   * @param connection - Connection name (optional).
+   */
+  async clear(queue = "default", connection = this.defaultConnection) {
+    const driver = this.getDriver(connection);
+    await driver.clear(queue);
+  }
+};
+
+// src/OrbitStream.ts
+var OrbitStream = class _OrbitStream {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  queueManager;
+  consumer;
+  /**
+   * Static configuration helper.
+   */
+  static configure(options) {
+    return new _OrbitStream(options);
+  }
+  /**
+   * Install into PlanetCore.
+   */
+  install(core) {
+    this.queueManager = new QueueManager(this.options);
+    core.adapter.use("*", async (c, next) => {
+      if (this.queueManager && this.options.connections) {
+        for (const [name, config] of Object.entries(this.options.connections)) {
+          if (config.driver === "database" && !config.dbService) {
+            try {
+              const dbService = c.get("db");
+              if (dbService) {
+                try {
+                  this.queueManager.getDriver(name);
+                } catch {
+                  this.queueManager.registerConnection(name, {
+                    ...config,
+                    dbService
+                  });
+                }
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      c.set("queue", this.queueManager);
+      await next();
+      return void 0;
+    });
+    core.logger.info("[OrbitStream] Installed");
+    if (this.options.autoStartWorker && process.env.NODE_ENV === "development" && this.options.workerOptions) {
+      this.startWorker(this.options.workerOptions);
+    }
+  }
+  /**
+   * Start embedded worker.
+   */
+  startWorker(options) {
+    if (!this.queueManager) {
+      throw new Error("QueueManager not initialized. Call install() first.");
+    }
+    if (this.consumer?.isRunning()) {
+      throw new Error("Worker is already running");
+    }
+    this.consumer = new Consumer(this.queueManager, options);
+    this.consumer.start().catch((error) => {
+      console.error("[OrbitStream] Worker error:", error);
+    });
+  }
+  /**
+   * Stop embedded worker.
+   */
+  async stopWorker() {
+    if (this.consumer) {
+      await this.consumer.stop();
+    }
+  }
+  /**
+   * Get QueueManager instance.
+   */
+  getQueueManager() {
+    return this.queueManager;
+  }
+};
+export {
+  ClassNameSerializer,
+  Consumer,
+  DatabaseDriver,
+  Job,
+  JsonSerializer,
+  KafkaDriver,
+  MemoryDriver,
+  OrbitStream,
+  QueueManager,
+  RedisDriver,
+  SQSDriver,
+  Worker
+};