@quantabit/job-sdk 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,774 @@
+import { BaseApiClient } from '@quantabit/sdk-config';
+import React, { useState, useCallback, useEffect } from 'react';
+
+/**
+ * QuantaBit Job SDK - jobApi Service
+ * 
+ * 用于向后端分布式任务中心发送管理指令（如获取队列健康度、触发即时任务、重试失败任务）
+ */
+
+class JobApiClient extends BaseApiClient {
+  constructor(config = {}) {
+    super('/jobs', config);
+  }
+
+  // 获取所有队列的状态与统计信息
+  async getQueueStats() {
+    return this.get('/stats');
+  }
+
+  // 触发一个后台即时任务
+  async triggerJob(jobName, payload = {}) {
+    return this.post('/trigger', {
+      jobName,
+      payload
+    });
+  }
+
+  // 停止指定任务
+  async cancelJob(jobId) {
+    return this.post(`/cancel/${jobId}`);
+  }
+
+  // 重试失败的任务
+  async retryJob(jobId) {
+    return this.post(`/retry/${jobId}`);
+  }
+}
+const jobApi = new JobApiClient();
+
+/**
+ * QuantaBit Job SDK - useJob Hook
+ * 
+ * 用于获取与管理分布式任务队列状态，支持手动触发、重试任务
+ */
+
+function useJob() {
+  const [queues, setQueues] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchStats = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await jobApi.getQueueStats();
+      setQueues(data?.queues || []);
+    } catch (err) {
+      setError(err);
+      // 开发阶段兜底模拟数据
+      setQueues([{
+        name: 'default-queue',
+        active: 3,
+        completed: 420,
+        failed: 2,
+        delayed: 0
+      }, {
+        name: 'email-sender',
+        active: 0,
+        completed: 1850,
+        failed: 14,
+        delayed: 2
+      }, {
+        name: 'chain-syncer',
+        active: 1,
+        completed: 95402,
+        failed: 1,
+        delayed: 0
+      }]);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const trigger = useCallback(async (jobName, payload) => {
+    setLoading(true);
+    try {
+      await jobApi.triggerJob(jobName, payload);
+      await fetchStats();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchStats]);
+  const retry = useCallback(async jobId => {
+    setLoading(true);
+    try {
+      await jobApi.retryJob(jobId);
+      await fetchStats();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchStats]);
+  useEffect(() => {
+    fetchStats();
+  }, [fetchStats]);
+  return {
+    queues,
+    loading,
+    error,
+    refresh: fetchStats,
+    trigger,
+    retry
+  };
+}
+
+/**
+ * QuantaBit Job SDK - i18n support
+ */
+
+const messages = {
+  en: {
+    jobMonitor: 'Distributed Job Queue Monitor',
+    queueName: 'Queue Name',
+    activeJobs: 'Active',
+    completedJobs: 'Completed',
+    failedJobs: 'Failed',
+    delayedJobs: 'Delayed',
+    actions: 'Actions',
+    triggerJob: 'Trigger Task',
+    retryAll: 'Retry Failed',
+    status: 'Status',
+    lastUpdated: 'Last Updated'
+  },
+  zh: {
+    jobMonitor: '分布式任务队列监视器',
+    queueName: '队列名称',
+    activeJobs: '活动中',
+    completedJobs: '已完成',
+    failedJobs: '已失败',
+    delayedJobs: '已延迟',
+    actions: '操作',
+    triggerJob: '手动触发任务',
+    retryAll: '重试失败任务',
+    status: '状态',
+    lastUpdated: '最近更新'
+  },
+  ja: {
+    jobMonitor: '分散ジョブキューモニター',
+    queueName: 'キュー名',
+    activeJobs: '実行中',
+    completedJobs: '完了済み',
+    failedJobs: '失敗',
+    delayedJobs: '遅延',
+    actions: 'アクション',
+    triggerJob: 'タスクをトリガー',
+    retryAll: '失敗タスクを再試行',
+    status: 'ステータス',
+    lastUpdated: '最終更新'
+  },
+  ko: {
+    jobMonitor: '분산 작업 큐 모니터',
+    queueName: '큐 이름',
+    activeJobs: '활성 작업',
+    completedJobs: '완료됨',
+    failedJobs: '실패함',
+    delayedJobs: '지연됨',
+    actions: '작업',
+    triggerJob: '작업 트리거',
+    retryAll: '실패 작업 재시도',
+    status: '상태',
+    lastUpdated: '최근 업데이트'
+  }
+};
+const SUPPORTED_LANGUAGES = ['en', 'zh', 'ja', 'ko'];
+let currentLanguage = 'en';
+function setLanguage(lang) {
+  if (SUPPORTED_LANGUAGES.includes(lang)) currentLanguage = lang;
+}
+function getLanguage() {
+  return currentLanguage;
+}
+function t(key) {
+  return (messages[currentLanguage] || messages.en)[key] || key;
+}
+
+/**
+ * QuantaBit Job SDK - JobMonitor Component
+ * 
+ * 任务队列监控面板组件，实时展现当前系统的分布式任务引擎吞吐状况，并允许运维触发或重试任务。
+ */
+
+function JobMonitor({
+  className = ''
+}) {
+  const {
+    queues,
+    loading,
+    refresh,
+    trigger,
+    retry
+  } = useJob();
+  const [showTriggerModal, setShowTriggerModal] = useState(false);
+  const [targetQueue, setTargetQueue] = useState('');
+  const [jobPayload, setJobPayload] = useState('{}');
+  const handleTriggerSubmit = async e => {
+    e.preventDefault();
+    let payloadObj = {};
+    try {
+      payloadObj = JSON.parse(jobPayload);
+    } catch (_) {
+      // 保持空对象
+    }
+    await trigger(targetQueue, payloadObj);
+    setShowTriggerModal(false);
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    className: `qbit-job-monitor ${className}`
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "qbit-monitor-header"
+  }, /*#__PURE__*/React.createElement("h4", null, t('jobMonitor')), /*#__PURE__*/React.createElement("div", {
+    className: "qbit-monitor-actions"
+  }, /*#__PURE__*/React.createElement("button", {
+    className: "qbit-btn-refresh",
+    onClick: refresh,
+    disabled: loading
+  }, loading ? '...' : 'Refresh'))), /*#__PURE__*/React.createElement("div", {
+    className: "qbit-monitor-body"
+  }, /*#__PURE__*/React.createElement("table", {
+    className: "qbit-monitor-table"
+  }, /*#__PURE__*/React.createElement("thead", null, /*#__PURE__*/React.createElement("tr", null, /*#__PURE__*/React.createElement("th", null, t('queueName')), /*#__PURE__*/React.createElement("th", null, t('activeJobs')), /*#__PURE__*/React.createElement("th", null, t('completedJobs')), /*#__PURE__*/React.createElement("th", null, t('failedJobs')), /*#__PURE__*/React.createElement("th", null, t('delayedJobs')), /*#__PURE__*/React.createElement("th", null, t('actions')))), /*#__PURE__*/React.createElement("tbody", null, queues.map(q => /*#__PURE__*/React.createElement("tr", {
+    key: q.name
+  }, /*#__PURE__*/React.createElement("td", {
+    className: "qbit-queue-name"
+  }, q.name), /*#__PURE__*/React.createElement("td", null, /*#__PURE__*/React.createElement("span", {
+    className: "qbit-badge active"
+  }, q.active)), /*#__PURE__*/React.createElement("td", null, /*#__PURE__*/React.createElement("span", {
+    className: "qbit-badge completed"
+  }, q.completed)), /*#__PURE__*/React.createElement("td", null, /*#__PURE__*/React.createElement("span", {
+    className: "qbit-badge failed"
+  }, q.failed)), /*#__PURE__*/React.createElement("td", null, /*#__PURE__*/React.createElement("span", {
+    className: "qbit-badge delayed"
+  }, q.delayed)), /*#__PURE__*/React.createElement("td", null, /*#__PURE__*/React.createElement("div", {
+    className: "qbit-row-actions"
+  }, /*#__PURE__*/React.createElement("button", {
+    className: "qbit-btn-trigger",
+    onClick: () => {
+      setTargetQueue(q.name);
+      setShowTriggerModal(true);
+    }
+  }, t('triggerJob')), q.failed > 0 && /*#__PURE__*/React.createElement("button", {
+    className: "qbit-btn-retry",
+    onClick: () => retry(q.name)
+  }, t('retryAll'))))))))), showTriggerModal && /*#__PURE__*/React.createElement("div", {
+    className: "qbit-monitor-modal-backdrop"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "qbit-monitor-modal"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "qbit-modal-header"
+  }, /*#__PURE__*/React.createElement("h5", null, "Trigger Job on [", targetQueue, "]"), /*#__PURE__*/React.createElement("button", {
+    className: "close",
+    onClick: () => setShowTriggerModal(false)
+  }, "\xD7")), /*#__PURE__*/React.createElement("form", {
+    onSubmit: handleTriggerSubmit
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "qbit-form-group"
+  }, /*#__PURE__*/React.createElement("label", null, "Job Payload (JSON)"), /*#__PURE__*/React.createElement("textarea", {
+    value: jobPayload,
+    onChange: e => setJobPayload(e.target.value),
+    rows: 4,
+    placeholder: "{\"userId\": 101, \"action\": \"sync\"}"
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "qbit-modal-footer"
+  }, /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: "btn-cancel",
+    onClick: () => setShowTriggerModal(false)
+  }, "Cancel"), /*#__PURE__*/React.createElement("button", {
+    type: "submit",
+    className: "btn-submit"
+  }, "Submit Task"))))), /*#__PURE__*/React.createElement("style", null, `
+        .qbit-job-monitor {
+          background: #0f172a;
+          color: #f8fafc;
+          border-radius: 12px;
+          border: 1px solid #1e293b;
+          font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+          box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+          overflow: hidden;
+          width: 100%;
+        }
+        .qbit-monitor-header {
+          background: #1e293b;
+          padding: 16px 20px;
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          border-bottom: 1px solid #334155;
+        }
+        .qbit-monitor-header h4 {
+          margin: 0;
+          font-size: 15px;
+          font-weight: 600;
+          color: #f1f5f9;
+        }
+        .qbit-btn-refresh {
+          background: transparent;
+          border: 1px solid #475569;
+          color: #cbd5e1;
+          padding: 6px 12px;
+          border-radius: 6px;
+          font-size: 13px;
+          cursor: pointer;
+          transition: background 0.2s;
+        }
+        .qbit-btn-refresh:hover {
+          background: #334155;
+        }
+        .qbit-monitor-body {
+          padding: 20px;
+          overflow-x: auto;
+        }
+        .qbit-monitor-table {
+          width: 100%;
+          border-collapse: collapse;
+          text-align: left;
+          font-size: 13px;
+        }
+        .qbit-monitor-table th {
+          color: #94a3b8;
+          font-weight: 500;
+          padding: 10px 12px;
+          border-bottom: 1px solid #334155;
+          text-transform: uppercase;
+          font-size: 11px;
+        }
+        .qbit-monitor-table td {
+          padding: 12px;
+          border-bottom: 1px solid #33415540;
+          color: #cbd5e1;
+        }
+        .qbit-queue-name {
+          font-family: monospace;
+          color: #38bdf8;
+          font-weight: bold;
+        }
+        .qbit-badge {
+          display: inline-block;
+          padding: 2px 6px;
+          border-radius: 4px;
+          font-weight: bold;
+          font-size: 11px;
+        }
+        .qbit-badge.active {
+          background: rgba(59, 130, 246, 0.15);
+          color: #60a5fa;
+        }
+        .qbit-badge.completed {
+          background: rgba(16, 185, 129, 0.15);
+          color: #34d399;
+        }
+        .qbit-badge.failed {
+          background: rgba(239, 68, 68, 0.15);
+          color: #f87171;
+        }
+        .qbit-badge.delayed {
+          background: rgba(245, 158, 11, 0.15);
+          color: #fbbf24;
+        }
+        .qbit-row-actions {
+          display: flex;
+          gap: 8px;
+        }
+        .qbit-btn-trigger, .qbit-btn-retry {
+          background: #1e293b;
+          border: 1px solid #334155;
+          color: #94a3b8;
+          padding: 4px 8px;
+          border-radius: 4px;
+          font-size: 11px;
+          cursor: pointer;
+          transition: all 0.2s;
+        }
+        .qbit-btn-trigger:hover {
+          background: #3b82f620;
+          color: #60a5fa;
+          border-color: #3b82f640;
+        }
+        .qbit-btn-retry:hover {
+          background: #ef444420;
+          color: #f87171;
+          border-color: #ef444440;
+        }
+        .qbit-monitor-modal-backdrop {
+          position: fixed;
+          top: 0;
+          left: 0;
+          right: 0;
+          bottom: 0;
+          background: rgba(15, 23, 42, 0.7);
+          backdrop-filter: blur(4px);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          z-index: 1001;
+        }
+        .qbit-monitor-modal {
+          background: #1e293b;
+          color: #f8fafc;
+          border-radius: 12px;
+          border: 1px solid #334155;
+          width: 90%;
+          max-width: 440px;
+          padding: 20px;
+          box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.5);
+        }
+        .qbit-modal-header {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          margin-bottom: 16px;
+        }
+        .qbit-modal-header h5 {
+          margin: 0;
+          font-size: 14px;
+          color: #f1f5f9;
+        }
+        .qbit-modal-header .close {
+          background: transparent;
+          border: none;
+          color: #94a3b8;
+          font-size: 20px;
+          cursor: pointer;
+        }
+        .qbit-form-group {
+          display: flex;
+          flex-direction: column;
+          gap: 6px;
+          margin-bottom: 16px;
+        }
+        .qbit-form-group label {
+          font-size: 11px;
+          color: #94a3b8;
+          text-transform: uppercase;
+        }
+        .qbit-form-group textarea {
+          background: #0f172a;
+          border: 1px solid #334155;
+          border-radius: 6px;
+          padding: 8px;
+          color: #f8fafc;
+          font-family: monospace;
+          outline: none;
+          font-size: 12px;
+        }
+        .qbit-form-group textarea:focus {
+          border-color: #3b82f6;
+        }
+        .qbit-modal-footer {
+          display: flex;
+          justify-content: flex-end;
+          gap: 8px;
+        }
+        .btn-cancel, .btn-submit {
+          padding: 8px 16px;
+          border-radius: 6px;
+          font-size: 12px;
+          cursor: pointer;
+          border: none;
+          font-weight: 500;
+        }
+        .btn-cancel {
+          background: transparent;
+          color: #cbd5e1;
+          border: 1px solid #475569;
+        }
+        .btn-cancel:hover {
+          background: #334155;
+        }
+        .btn-submit {
+          background: #3b82f6;
+          color: white;
+        }
+        .btn-submit:hover {
+          background: #2563eb;
+        }
+      `));
+}
+
+var uuid = require('uuid');
+var bullmq = require('bullmq');
+var amqp = require('amqplib');
+class BaseAdapter {
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async connect() {
+    throw new Error('connect() must be implemented');
+  }
+  async disconnect() {
+    throw new Error('disconnect() must be implemented');
+  }
+  async publish(queueName, payload, options = {}) {
+    throw new Error('publish() must be implemented');
+  }
+  async consume(queueName, callback, options = {}) {
+    throw new Error('consume() must be implemented');
+  }
+}
+class RedisAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super(config);
+    // BullMQ / ioredis connection
+    if (!this.config.connection) {
+      throw new Error('[RedisAdapter] config.connection is required (e.g. { host, port })');
+    }
+    this.connection = this.config.connection;
+    this.queues = new Map();
+    this.workers = new Map();
+  }
+  async connect() {
+    // BullMQ automatically establishes connection upon queue creation
+    console.log('[RedisAdapter] Initialized with redis config:', this.connection);
+  }
+  async disconnect() {
+    for (const worker of this.workers.values()) {
+      await worker.close();
+    }
+    for (const queue of this.queues.values()) {
+      await queue.close();
+    }
+    this.workers.clear();
+    this.queues.clear();
+    console.log('[RedisAdapter] Disonnected gracefully');
+  }
+  _getQueue(queueName) {
+    if (!this.queues.has(queueName)) {
+      const q = new bullmq.Queue(queueName, {
+        connection: this.connection
+      });
+      this.queues.set(queueName, q);
+    }
+    return this.queues.get(queueName);
+  }
+  async publish(queueName, payload, options = {}) {
+    const q = this._getQueue(queueName);
+    const jobName = options.jobName || 'defaultJob';
+
+    // Transform standardize options into BullMQ options
+    const bullOptions = {
+      jobId: options.fixedId,
+      // specific ID for deduplication 
+      delay: options.delay,
+      // In ms
+      attempts: options.retries || 3,
+      backoff: options.backoff || {
+        type: 'exponential',
+        delay: 1000
+      },
+      ...options.adapterOptions
+    };
+    const job = await q.add(jobName, payload, bullOptions);
+    return job.id;
+  }
+  async consume(queueName, callback, options = {}) {
+    if (this.workers.has(queueName)) {
+      console.warn(`[RedisAdapter] Worker for queue [${queueName}] already exists.`);
+      return;
+    }
+
+    // Bullmq worker implementation
+    const worker = new bullmq.Worker(queueName, async job => {
+      // Execute standardized callback
+      await callback(job.data, job);
+    }, {
+      connection: this.connection,
+      concurrency: options.concurrency || 1,
+      ...options.adapterOptions
+    });
+    worker.on('failed', (job, err) => {
+      console.error(`[RedisAdapter] Job ${job?.id} failed in queue [${queueName}]:`, err.message);
+    });
+    this.workers.set(queueName, worker);
+    console.log(`[RedisAdapter] Worker for queue [${queueName}] started (Concurrency: ${options.concurrency || 1})`);
+  }
+}
+class RabbitMQAdapter extends BaseAdapter {
+  constructor(config = {}) {
+    super(config);
+    if (!this.config.url) {
+      throw new Error('[RabbitMQAdapter] config.url is required (e.g. amqp://host)');
+    }
+    this.url = this.config.url;
+    this.connection = null;
+    this.channelPool = new Map(); // queueName -> channel
+  }
+  async connect() {
+    if (!this.connection) {
+      try {
+        this.connection = await amqp.connect(this.url);
+        console.log('[RabbitMQAdapter] Connected to amqp broker:', this.url);
+
+        // Auto retry logic on unexpected close
+        this.connection.on('error', err => {
+          console.error('[RabbitMQAdapter] Connection error:', err.message);
+        });
+        this.connection.on('close', () => {
+          console.warn('[RabbitMQAdapter] Connection closed!');
+          this.connection = null;
+          // You could implement auto-reconnect backoffs here
+        });
+      } catch (err) {
+        console.error('[RabbitMQAdapter] Initial amqp connect failed:', err.message);
+        throw err;
+      }
+    }
+  }
+  async disconnect() {
+    for (const [queueName, channel] of this.channelPool.entries()) {
+      await channel.close();
+    }
+    this.channelPool.clear();
+    if (this.connection) {
+      await this.connection.close();
+      this.connection = null;
+    }
+    console.log('[RabbitMQAdapter] Disonnected gracefully');
+  }
+  async _getChannel() {
+    if (!this.connection) await this.connect();
+    return await this.connection.createChannel();
+  }
+  async publish(queueName, payload, options = {}) {
+    const channel = await this._getChannel();
+    await channel.assertQueue(queueName, {
+      durable: true
+    });
+
+    // Support specific TTL / delay via rabbitmq x-message-ttl 
+    // Usually requires delayed-message-exchange plugin for robust delay,
+    // this keeps it simple for now standard durable push
+    const headers = options.headers || {};
+    const sent = channel.sendToQueue(queueName, Buffer.from(JSON.stringify(payload)), {
+      persistent: true,
+      headers,
+      ...options.adapterOptions
+    });
+    await channel.close();
+    return sent ? 'sent' : 'failed';
+  }
+  async consume(queueName, callback, options = {}) {
+    if (this.channelPool.has(queueName)) {
+      console.warn(`[RabbitMQAdapter] Worker for queue [${queueName}] already attached.`);
+      return;
+    }
+    const channel = await this._getChannel();
+    await channel.assertQueue(queueName, {
+      durable: true
+    });
+    if (options.concurrency) {
+      await channel.prefetch(options.concurrency);
+    }
+    channel.consume(queueName, async msg => {
+      if (msg !== null) {
+        try {
+          const payload = JSON.parse(msg.content.toString());
+          await callback(payload, msg);
+          channel.ack(msg); // ack securely
+        } catch (err) {
+          console.error(`[RabbitMQAdapter] Error processing standard message:`, err.message);
+          // if re-queue flag isn't disabled, attempt multiple retries manually or drop it to dead-letter exchange
+          const requeue = options.requeue !== false;
+          channel.nack(msg, false, requeue);
+        }
+      }
+    }, options.adapterOptions);
+    this.channelPool.set(queueName, channel);
+    console.log(`[RabbitMQAdapter] AMQP channel consuming [${queueName}] (Concurrency: ${options.concurrency || 1})`);
+  }
+}
+
+/**
+ * Universal Job Queue SDK designed for scalable infra.
+ */
+class JobQueue {
+  /**
+   * Initialize SDK with desired engine config.
+   * @param {Object} options
+   * @param {'redis' | 'rabbitmq'} [options.engine='redis'] - Core transport choice.
+   * @param {Object} [options.config] - Driver-specific options block i.e., config.url or config.connection.
+   */
+  constructor(options = {}) {
+    this.engine = options.engine || 'redis';
+    this.config = options.config || {};
+
+    // Plug matching adapter to uniform base footprint
+    if (this.engine === 'redis') {
+      this.adapter = new RedisAdapter(this.config);
+    } else if (this.engine === 'rabbitmq') {
+      this.adapter = new RabbitMQAdapter(this.config);
+    } else {
+      throw new Error(`Unsupported engine: ${this.engine}. Use 'redis' or 'rabbitmq'`);
+    }
+  }
+
+  /**
+   * Bind connections actively to infrastructure backing service.
+   */
+  async connect() {
+    await this.adapter.connect();
+  }
+
+  /**
+   * Drain queue streams and kill connections cleanly.
+   */
+  async disconnect() {
+    await this.adapter.disconnect();
+  }
+
+  /**
+   * Push unified shape job payload.
+   * @param {string} queueName Queue tag.
+   * @param {Object} customData Business domain object to be acted on.
+   * @param {Object} options Standard SDK options mapping features consistently across engines.
+   * @returns {Promise<string>} Trackable job/execution ID.
+   */
+  async publishTask(queueName, customData, options = {}) {
+    const formattedTask = {
+      taskId: uuid.v4(),
+      timestamp: Date.now(),
+      source: options.source || 'qbit-backend-sdk',
+      data: customData || {},
+      ...options.metadata
+    };
+    const executionId = await this.adapter.publish(queueName, formattedTask, options);
+    console.log(`[JobQueue][${this.engine}] published task [${formattedTask.taskId}] to [${queueName}]`);
+    return executionId || formattedTask.taskId;
+  }
+
+  /**
+   * Subscribe uniform pipeline logic against generic engine transport loop.
+   * 
+   * @param {string} queueName Event path.
+   * @param {Function} handler The processor async (data, context) => {} -> context exposes tracing.
+   * @param {Object} options Extra pipeline overrides matching to underlying plugins mapping cleanly.
+   */
+  async consumeTask(queueName, handler, options = {}) {
+    console.log(`[JobQueue][${this.engine}] Init consuming [${queueName}] with driver mapping.`);
+    await this.adapter.consume(queueName, async (rawPayload, rawJob) => {
+      // Decode meta contexts & execute the business fn
+      const bizData = rawPayload.data || rawPayload;
+      const pipelineContext = {
+        taskId: rawPayload.taskId,
+        source: rawPayload.source,
+        timestamp: rawPayload.timestamp,
+        metadata: rawPayload,
+        // Access extra decorated tags
+        raw: rawJob // Break glass back to amqplib/bull node for rare deep interactions
+      };
+      await handler(bizData, pipelineContext);
+    }, options);
+  }
+}
+exports.BaseAdapter = BaseAdapter;
+exports.JobQueue = JobQueue;
+exports.RabbitMQAdapter = RabbitMQAdapter;
+exports.RedisAdapter = RedisAdapter;
+
+export { JobApiClient, JobMonitor, SUPPORTED_LANGUAGES, getLanguage, jobApi, messages, setLanguage, t, useJob };
+//# sourceMappingURL=index.esm.js.map