vona-module-a-queue 5.0.10 → 5.0.12

package/dist/index.js

@@ -1,3 +1,334 @@
-export * from "./.metadata/index.js";
-export * from "./lib/index.js";
-export * from "./types/index.js";
+import { BeanInfo, BeanBase, BeanSimple, uuidv4, deepExtend, instanceDesp, beanFullNameFromOnionName, BeanScopeBase, createBeanDecorator } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+import { Startup } from 'vona-module-a-startup';
+import * as Bull from 'bullmq';
+import { Service } from 'vona-module-a-web';
+
+var _dec$2, _dec2$2, _class$2;
+let StartupLoadQueueWorkers = (_dec$2 = Startup({
+  instance: true,
+  after: true
+}), _dec2$2 = BeanInfo({
+  module: "a-queue"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = class StartupLoadQueueWorkers extends BeanBase {
+  async execute() {
+    // load queue workers
+    if (!this.app.meta.isTest) {
+      this.scope.service.queue.loadQueueWorkers(this.ctx.instanceName);
+    }
+  }
+}) || _class$2) || _class$2);
+
+function config(_app) {
+  return {
+    worker: {
+      lockDuration: 30 * 1000,
+      maxStalledCount: 1000,
+      stalledInterval: 10 * 1000
+    }
+  };
+}
+
+const __ThisModule__ = 'a-queue';
+
+class Monkey extends BeanSimple {
+  async appClose() {
+    const scopeSelf = this.bean.scope(__ThisModule__);
+    await scopeSelf.service.queue.clearWorkers();
+  }
+  async appClosed() {
+    const scopeSelf = this.bean.scope(__ThisModule__);
+    await scopeSelf.service.queue.clearQueues();
+  }
+}
+
+var _dec$1, _dec2$1, _class$1;
+let ServiceQueue = (_dec$1 = Service(), _dec2$1 = BeanInfo({
+  module: "a-queue"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = class ServiceQueue extends BeanBase {
+  constructor(...args) {
+    super(...args);
+    this._workers = {};
+    this._queues = {};
+    this._queueCallbacks = {};
+  }
+  push(info) {
+    if (!info.options?.dbInfo) throw new Error('should specify the options.dbInfo');
+    this._queuePush(info, false);
+  }
+
+  // { locale, instanceName, module, queueName,queueNameSub,data }
+  pushAsync(info) {
+    if (!info.options?.dbInfo) throw new Error('should specify the options.dbInfo');
+    return this._queuePush(info, true);
+  }
+  loadQueueWorkers(instanceName) {
+    for (const queueItem of this.bean.onion.queue.getOnionsEnabled()) {
+      const info = {
+        queueName: queueItem.name,
+        data: undefined,
+        options: {
+          instanceName
+        }
+      };
+      this._ensureWorker(info);
+    }
+  }
+  async clearWorkers() {
+    for (const queueKey in this._workers) {
+      const _worker = this._workers[queueKey];
+      await _worker.worker.close();
+    }
+    this._workers = {};
+  }
+  async clearQueues() {
+    for (const queueKey in this._queues) {
+      const _queue = this._queues[queueKey];
+      await _queue.queue.close();
+      await _queue.queueEvents.close();
+    }
+    this._queues = {};
+  }
+  _createWorker(info, queueKey) {
+    const app = this.app;
+    // worker
+    const _worker = {};
+    // prefix
+    const prefix = `bull_${app.name}:queue`;
+    // queue config
+    const queueConfig = app.bean.onion.queue.getOnionOptions(info.queueName);
+    // queueConfig.options: queue/worker/job/redlock
+    const workerOptions = queueConfig?.options?.worker;
+    const redlockOptions = queueConfig?.options?.redlock;
+    const _redlockOptions = Object.assign({}, this.$scope.redlock.config.redlock.options, redlockOptions);
+    const _lockTTL = redlockOptions?.lockTTL ?? this.$scope.redlock.config.redlock.lockTTL;
+
+    // redlock
+    if (!queueConfig?.concurrency) {
+      _worker.redlock = this.$scope.redlock.service.redlock.create(_redlockOptions);
+    }
+
+    // create work
+    const connectionWorker = app.bean.redis.get('queue');
+    const _workerOptions = Object.assign({}, this.scope.config.worker, workerOptions, {
+      prefix,
+      connection: connectionWorker
+    });
+    _worker.workerOptions = _workerOptions;
+    _worker.worker = new Bull.Worker(queueKey, async job => {
+      // concurrency
+      if (queueConfig?.concurrency) {
+        return await this._performTask(job);
+      }
+      // redlock
+      const info = job.data;
+      const queueNameSub = info.options?.queueNameSub;
+      const _lockResource = `queue:${queueKey}${queueNameSub ? `#${queueNameSub}` : ''}`;
+      return await this.$scope.redlock.service.redlock.lock(_lockResource, async () => {
+        return await this._performTask(job);
+      }, {
+        // instanceName: job.data.instanceName, // need not
+        redlock: _worker.redlock,
+        lockTTL: _lockTTL
+      });
+    }, _workerOptions);
+    _worker.worker.on('failed', (_job, err) => {
+      this.$logger.error(err);
+    });
+    _worker.worker.on('error', err => {
+      if (err.message && err.message.includes('Missing lock for job')) {
+        const workerInner = _worker.worker;
+        if (!workerInner.running) {
+          _worker.worker.run().catch(err => {
+            this.$logger.error(err);
+          });
+        }
+      }
+    });
+
+    // ok
+    return _worker;
+  }
+  _createQueue(info, queueKey) {
+    const app = this.app;
+    // queue
+    const _queue = {};
+    // prefix
+    const prefix = `bull_${app.name}:queue`;
+    // queue config
+    const queueConfig = app.bean.onion.queue.getOnionOptions(info.queueName);
+    // queueConfig.options: queue/worker/job/limiter
+    const queueOptions = queueConfig?.options?.queue;
+
+    // create queue
+    const connectionQueue = app.bean.redis.get('queue');
+    const _queueOptions = Object.assign({}, queueOptions, {
+      prefix,
+      connection: connectionQueue
+    });
+    _queue.config = queueConfig;
+    _queue.options = _queueOptions;
+    _queue.queue = new Bull.Queue(queueKey, _queueOptions);
+
+    // create events
+    const connectionEvents = app.bean.redis.get('queue');
+    const _queueEventsOptions = {
+      prefix,
+      connection: connectionEvents
+    };
+    _queue.queueEventsOptions = _queueEventsOptions;
+    _queue.queueEvents = new Bull.QueueEvents(queueKey, _queueEventsOptions);
+    _queue.queueEvents.on('completed', ({
+      jobId,
+      returnvalue
+    }) => {
+      this._callCallback(jobId, undefined, returnvalue);
+    });
+    _queue.queueEvents.on('failed', ({
+      jobId,
+      failedReason
+    }) => {
+      this._callCallback(jobId, failedReason, undefined);
+    });
+
+    // ok
+    return _queue;
+  }
+  _ensureWorker(info) {
+    // queueKey
+    const queueKey = this._combineQueueKey(info);
+    // worker
+    if (!this._workers[queueKey]) {
+      this._workers[queueKey] = this._createWorker(info, queueKey);
+    }
+  }
+  _ensureQueue(info) {
+    // worker
+    this._ensureWorker(info);
+    // queueKey
+    const queueKey = this._combineQueueKey(info);
+    // queue
+    if (!this._queues[queueKey]) {
+      this._queues[queueKey] = this._createQueue(info, queueKey);
+    }
+    // ok
+    return this._queues[queueKey];
+  }
+  getQueue(queueName, instanceName) {
+    return this._getQueue({
+      queueName,
+      data: undefined,
+      options: {
+        instanceName: instanceName ?? this.ctx.instanceName
+      }
+    });
+  }
+  _getQueue(info) {
+    return this._ensureQueue(info).queue;
+  }
+  _callCallback(jobId, failedReason, data) {
+    const _callback = this._queueCallbacks[jobId];
+    if (_callback) {
+      delete this._queueCallbacks[jobId];
+      _callback.callback(failedReason ? new Error(failedReason) : undefined, data);
+    }
+  }
+  async _queuePush(info, isAsync) {
+    // queue config
+    const queueConfig = this.bean.onion.queue.getOnionOptions(info.queueName);
+    // queueConfig.options: queue/worker/job/limiter
+    const jobOptionsBase = queueConfig?.options?.job;
+    // queue
+    const queue = this._getQueue(info);
+    // job
+    const jobId = info.options?.jobOptions?.jobId || uuidv4();
+    const jobName = info.options?.jobName || jobId;
+    const jobOptions = deepExtend({
+      jobId
+    }, jobOptionsBase, info.options?.jobOptions);
+    // should not change info, hold original info.options?.jobName, info.options?.jobOptions
+    // info = deepExtend({}, info, { options: { jobName, jobOptions } });
+    // not async
+    if (!isAsync) {
+      // add job
+      queue.add(jobName, info, jobOptions);
+      return undefined;
+    }
+    // async
+    return new Promise((resolve, reject) => {
+      // callback
+      this._queueCallbacks[jobId] = {
+        info,
+        callback: (err, data) => {
+          if (err) return reject(err);
+          resolve(data);
+        }
+      };
+      // add job
+      return queue.add(jobName, info, jobOptions);
+    });
+  }
+  _combineQueueKey(info) {
+    const instanceName = instanceDesp(info.options?.instanceName);
+    return `${instanceName}||${beanFullNameFromOnionName(info.queueName, 'queue')}`;
+  }
+  async _performTask(job) {
+    const info = job.data;
+    // queue config
+    const queueItem = this.bean.onion.queue.getOnionSlice(info.queueName);
+    const queueConfig = this.bean.onion.queue.getOnionOptions(info.queueName);
+    // execute
+    return await this.bean.executor.newCtx(async () => {
+      const beanFullName = queueItem.beanOptions.beanFullName;
+      const beanInstance = this.app.bean._getBean(beanFullName);
+      return await beanInstance.execute(info.data, info.options, job);
+    }, {
+      dbInfo: info.options?.dbInfo,
+      locale: info.options?.locale,
+      instanceName: info.options?.instanceName,
+      extraData: info.options?.extraData,
+      transaction: queueConfig?.transaction
+    });
+  }
+  getRepeatKey(jobName, repeat) {
+    const endDate = repeat.endDate ? new Date(repeat.endDate).getTime() : '';
+    const tz = repeat.tz || '';
+    const pattern = repeat.pattern;
+    const suffix = pattern || String(repeat.every) || '';
+    return `${jobName}:${endDate}:${tz}:${suffix}`;
+  }
+  prepareJobInfo(queueName, data, options) {
+    options = this.$scope.executor.service.executor.prepareGeneralInfo(options);
+    // info
+    return {
+      queueName,
+      data,
+      options
+    };
+  }
+}) || _class$1) || _class$1);
+
+var _dec, _dec2, _class;
+let ScopeModuleAQueue = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-queue"
+}), _dec(_class = _dec2(_class = class ScopeModuleAQueue extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+class BeanQueueBase extends BeanBase {
+  async pushAsync(data, options) {
+    return await this.$scope.queue.service.queue.pushAsync(this.$scope.queue.service.queue.prepareJobInfo(this.$onionName, data, options));
+  }
+  push(data, options) {
+    return this.$scope.queue.service.queue.push(this.$scope.queue.service.queue.prepareJobInfo(this.$onionName, data, options));
+  }
+  getQueue(instanceName) {
+    return this.$scope.queue.service.queue.getQueue(this.$onionName, instanceName);
+  }
+}
+
+function Queue(options) {
+  return createBeanDecorator('queue', options);
+}
+
+export { BeanQueueBase, Monkey, Queue, ScopeModuleAQueue, ServiceQueue, StartupLoadQueueWorkers, config };

package/dist/lib/beanQueueBase.d.ts

@@ -1,7 +1,8 @@
+import type { IInstanceRecord } from 'vona';
 import type { IQueuePushOptions } from '../types/queue.ts';
 import { BeanBase } from 'vona';
 export declare class BeanQueueBase<DATA = unknown, RESULT = unknown> extends BeanBase {
     pushAsync(data: DATA, options?: IQueuePushOptions): Promise<RESULT>;
     push(data: DATA, options?: IQueuePushOptions): void;
-    getQueue(instanceName?: string): import("bullmq").Queue<any, any, string, any, any, string>;
+    getQueue(instanceName?: keyof IInstanceRecord): import("bullmq").Queue<any, any, string, any, any, string>;
 }

package/dist/service/queue.d.ts

@@ -1,3 +1,4 @@
+import type { IInstanceRecord } from 'vona';
 import type { IQueueCallbacks, IQueueJobContext, IQueuePushOptions, IQueueQueue, IQueueQueues, IQueueRecord, IQueueWork, IQueueWorks, TypeQueueJob } from '../types/queue.ts';
 import * as Bull from 'bullmq';
 import { BeanBase } from 'vona';
@@ -7,14 +8,14 @@ export declare class ServiceQueue extends BeanBase {
     _queueCallbacks: IQueueCallbacks;
     push<DATA>(info: IQueueJobContext<DATA>): void;
     pushAsync<DATA, RESULT>(info: IQueueJobContext<DATA>): Promise<RESULT>;
-    loadQueueWorkers(instanceName?: string | undefined | null): void;
+    loadQueueWorkers(instanceName?: keyof IInstanceRecord | undefined | null): void;
     clearWorkers(): Promise<void>;
     clearQueues(): Promise<void>;
     _createWorker<DATA>(info: IQueueJobContext<DATA>, queueKey: string): IQueueWork;
     _createQueue<DATA>(info: IQueueJobContext<DATA>, queueKey: string): IQueueQueue;
     _ensureWorker<DATA>(info: IQueueJobContext<DATA>): void;
     _ensureQueue<DATA>(info: IQueueJobContext<DATA>): IQueueQueue;
-    getQueue(queueName: keyof IQueueRecord, instanceName?: string | undefined | null): Bull.Queue<any, any, string, any, any, string>;
+    getQueue(queueName: keyof IQueueRecord, instanceName?: keyof IInstanceRecord | undefined | null): Bull.Queue<any, any, string, any, any, string>;
     _getQueue<DATA>(info: IQueueJobContext<DATA>): Bull.Queue<any, any, string, any, any, string>;
     _callCallback<DATA>(jobId: string | number, failedReason: string | undefined, data: DATA | undefined): void;
     _queuePush<DATA, RESULT>(info: IQueueJobContext<DATA>, isAsync: boolean): Promise<RESULT>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-queue",
   "type": "module",
-  "version": "5.0.10",
+  "version": "5.0.12",
   "title": "a-queue",
   "vonaModule": {
     "dependencies": {},
@@ -49,6 +49,6 @@
   },
   "scripts": {
     "clean": "rimraf dist tsconfig.build.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }

package/dist/.metadata/index.js

@@ -1,32 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-/** service: end */
-/** service: begin */
-/** monkey: end */
-/** scope: begin */
-import { BeanScopeBase } from 'vona';
-import { Scope } from 'vona-module-a-bean';
-import 'vona';
-import 'vona';
-import 'vona';
-export * from "../bean/startup.loadQueueWorkers.js";
-/** service: end */
-/** config: begin */
-export * from "../config/config.js";
-/** config: end */
-/** monkey: begin */
-export * from "../monkey.js";
-/** startup: end */
-/** service: begin */
-export * from "../service/queue.js";
-let ScopeModuleAQueue = class ScopeModuleAQueue extends BeanScopeBase {
-};
-ScopeModuleAQueue = __decorate([
-    Scope()
-], ScopeModuleAQueue);
-export { ScopeModuleAQueue };
-/** scope: end */

package/dist/.metadata/this.js

@@ -1,2 +0,0 @@
-export const __ThisModule__ = 'a-queue';
-export { ScopeModuleAQueue as ScopeModule } from "./index.js";

package/dist/bean/startup.loadQueueWorkers.js

@@ -1,20 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { BeanBase } from 'vona';
-import { Startup } from 'vona-module-a-startup';
-let StartupLoadQueueWorkers = class StartupLoadQueueWorkers extends BeanBase {
-    async execute() {
-        // load queue workers
-        if (!this.app.meta.isTest) {
-            this.scope.service.queue.loadQueueWorkers(this.ctx.instanceName);
-        }
-    }
-};
-StartupLoadQueueWorkers = __decorate([
-    Startup({ instance: true, after: true })
-], StartupLoadQueueWorkers);
-export { StartupLoadQueueWorkers };

package/dist/config/config.js

@@ -1,9 +0,0 @@
-export function config(_app) {
-    return {
-        worker: {
-            lockDuration: 30 * 1000,
-            maxStalledCount: 1000,
-            stalledInterval: 10 * 1000,
-        },
-    };
-}

package/dist/lib/beanQueueBase.js

@@ -1,12 +0,0 @@
-import { BeanBase } from 'vona';
-export class BeanQueueBase extends BeanBase {
-    async pushAsync(data, options) {
-        return await this.$scope.queue.service.queue.pushAsync(this.$scope.queue.service.queue.prepareJobInfo(this.$onionName, data, options));
-    }
-    push(data, options) {
-        return this.$scope.queue.service.queue.push(this.$scope.queue.service.queue.prepareJobInfo(this.$onionName, data, options));
-    }
-    getQueue(instanceName) {
-        return this.$scope.queue.service.queue.getQueue(this.$onionName, instanceName);
-    }
-}

package/dist/lib/index.js

@@ -1,2 +0,0 @@
-export * from "./beanQueueBase.js";
-export * from "./queue.js";

package/dist/lib/queue.js

@@ -1,4 +0,0 @@
-import { createBeanDecorator } from 'vona';
-export function Queue(options) {
-    return createBeanDecorator('queue', options);
-}

package/dist/monkey.js

@@ -1,12 +0,0 @@
-import { BeanSimple } from 'vona';
-import { __ThisModule__ } from "./.metadata/this.js";
-export class Monkey extends BeanSimple {
-    async appClose() {
-        const scopeSelf = this.bean.scope(__ThisModule__);
-        await scopeSelf.service.queue.clearWorkers();
-    }
-    async appClosed() {
-        const scopeSelf = this.bean.scope(__ThisModule__);
-        await scopeSelf.service.queue.clearQueues();
-    }
-}

package/dist/service/queue.js

@@ -1,250 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import * as Bull from 'bullmq';
-import { BeanBase, beanFullNameFromOnionName, deepExtend, instanceDesp, uuidv4 } from 'vona';
-import { Service } from 'vona-module-a-web';
-let ServiceQueue = class ServiceQueue extends BeanBase {
-    _workers = {};
-    _queues = {};
-    _queueCallbacks = {};
-    push(info) {
-        if (!info.options?.dbInfo)
-            throw new Error('should specify the options.dbInfo');
-        this._queuePush(info, false);
-    }
-    // { locale, instanceName, module, queueName,queueNameSub,data }
-    pushAsync(info) {
-        if (!info.options?.dbInfo)
-            throw new Error('should specify the options.dbInfo');
-        return this._queuePush(info, true);
-    }
-    loadQueueWorkers(instanceName) {
-        for (const queueItem of this.bean.onion.queue.getOnionsEnabled()) {
-            const info = {
-                queueName: queueItem.name,
-                data: undefined,
-                options: {
-                    instanceName,
-                },
-            };
-            this._ensureWorker(info);
-        }
-    }
-    async clearWorkers() {
-        for (const queueKey in this._workers) {
-            const _worker = this._workers[queueKey];
-            await _worker.worker.close();
-        }
-        this._workers = {};
-    }
-    async clearQueues() {
-        for (const queueKey in this._queues) {
-            const _queue = this._queues[queueKey];
-            await _queue.queue.close();
-            await _queue.queueEvents.close();
-        }
-        this._queues = {};
-    }
-    _createWorker(info, queueKey) {
-        const app = this.app;
-        // worker
-        const _worker = {};
-        // prefix
-        const prefix = `bull_${app.name}:queue`;
-        // queue config
-        const queueConfig = app.bean.onion.queue.getOnionOptions(info.queueName);
-        // queueConfig.options: queue/worker/job/redlock
-        const workerOptions = queueConfig?.options?.worker;
-        const redlockOptions = queueConfig?.options?.redlock;
-        const _redlockOptions = Object.assign({}, this.$scope.redlock.config.redlock.options, redlockOptions);
-        const _lockTTL = redlockOptions?.lockTTL ?? this.$scope.redlock.config.redlock.lockTTL;
-        // redlock
-        if (!queueConfig?.concurrency) {
-            _worker.redlock = this.$scope.redlock.service.redlock.create(_redlockOptions);
-        }
-        // create work
-        const connectionWorker = app.bean.redis.get('queue');
-        const _workerOptions = Object.assign({}, this.scope.config.worker, workerOptions, {
-            prefix,
-            connection: connectionWorker,
-        });
-        _worker.workerOptions = _workerOptions;
-        _worker.worker = new Bull.Worker(queueKey, async (job) => {
-            // concurrency
-            if (queueConfig?.concurrency) {
-                return await this._performTask(job);
-            }
-            // redlock
-            const info = job.data;
-            const queueNameSub = info.options?.queueNameSub;
-            const _lockResource = `queue:${queueKey}${queueNameSub ? `#${queueNameSub}` : ''}`;
-            return await this.$scope.redlock.service.redlock.lock(_lockResource, async () => {
-                return await this._performTask(job);
-            }, {
-                // instanceName: job.data.instanceName, // need not
-                redlock: _worker.redlock,
-                lockTTL: _lockTTL,
-            });
-        }, _workerOptions);
-        _worker.worker.on('failed', (_job, err) => {
-            this.$logger.error(err);
-        });
-        _worker.worker.on('error', err => {
-            if (err.message && err.message.includes('Missing lock for job')) {
-                const workerInner = _worker.worker;
-                if (!workerInner.running) {
-                    _worker.worker.run().catch(err => {
-                        this.$logger.error(err);
-                    });
-                }
-            }
-        });
-        // ok
-        return _worker;
-    }
-    _createQueue(info, queueKey) {
-        const app = this.app;
-        // queue
-        const _queue = {};
-        // prefix
-        const prefix = `bull_${app.name}:queue`;
-        // queue config
-        const queueConfig = app.bean.onion.queue.getOnionOptions(info.queueName);
-        // queueConfig.options: queue/worker/job/limiter
-        const queueOptions = queueConfig?.options?.queue;
-        // create queue
-        const connectionQueue = app.bean.redis.get('queue');
-        const _queueOptions = Object.assign({}, queueOptions, { prefix, connection: connectionQueue });
-        _queue.config = queueConfig;
-        _queue.options = _queueOptions;
-        _queue.queue = new Bull.Queue(queueKey, _queueOptions);
-        // create events
-        const connectionEvents = app.bean.redis.get('queue');
-        const _queueEventsOptions = { prefix, connection: connectionEvents };
-        _queue.queueEventsOptions = _queueEventsOptions;
-        _queue.queueEvents = new Bull.QueueEvents(queueKey, _queueEventsOptions);
-        _queue.queueEvents.on('completed', ({ jobId, returnvalue }) => {
-            this._callCallback(jobId, undefined, returnvalue);
-        });
-        _queue.queueEvents.on('failed', ({ jobId, failedReason }) => {
-            this._callCallback(jobId, failedReason, undefined);
-        });
-        // ok
-        return _queue;
-    }
-    _ensureWorker(info) {
-        // queueKey
-        const queueKey = this._combineQueueKey(info);
-        // worker
-        if (!this._workers[queueKey]) {
-            this._workers[queueKey] = this._createWorker(info, queueKey);
-        }
-    }
-    _ensureQueue(info) {
-        // worker
-        this._ensureWorker(info);
-        // queueKey
-        const queueKey = this._combineQueueKey(info);
-        // queue
-        if (!this._queues[queueKey]) {
-            this._queues[queueKey] = this._createQueue(info, queueKey);
-        }
-        // ok
-        return this._queues[queueKey];
-    }
-    getQueue(queueName, instanceName) {
-        return this._getQueue({
-            queueName,
-            data: undefined,
-            options: {
-                instanceName: instanceName ?? this.ctx.instanceName,
-            },
-        });
-    }
-    _getQueue(info) {
-        return this._ensureQueue(info).queue;
-    }
-    _callCallback(jobId, failedReason, data) {
-        const _callback = this._queueCallbacks[jobId];
-        if (_callback) {
-            delete this._queueCallbacks[jobId];
-            _callback.callback(failedReason ? new Error(failedReason) : undefined, data);
-        }
-    }
-    async _queuePush(info, isAsync) {
-        // queue config
-        const queueConfig = this.bean.onion.queue.getOnionOptions(info.queueName);
-        // queueConfig.options: queue/worker/job/limiter
-        const jobOptionsBase = queueConfig?.options?.job;
-        // queue
-        const queue = this._getQueue(info);
-        // job
-        const jobId = info.options?.jobOptions?.jobId || uuidv4();
-        const jobName = info.options?.jobName || jobId;
-        const jobOptions = deepExtend({ jobId }, jobOptionsBase, info.options?.jobOptions);
-        // should not change info, hold original info.options?.jobName, info.options?.jobOptions
-        // info = deepExtend({}, info, { options: { jobName, jobOptions } });
-        // not async
-        if (!isAsync) {
-            // add job
-            queue.add(jobName, info, jobOptions);
-            return undefined;
-        }
-        // async
-        return new Promise((resolve, reject) => {
-            // callback
-            this._queueCallbacks[jobId] = {
-                info,
-                callback: (err, data) => {
-                    if (err)
-                        return reject(err);
-                    resolve(data);
-                },
-            };
-            // add job
-            return queue.add(jobName, info, jobOptions);
-        });
-    }
-    _combineQueueKey(info) {
-        const instanceName = instanceDesp(info.options?.instanceName);
-        return `${instanceName}||${beanFullNameFromOnionName(info.queueName, 'queue')}`;
-    }
-    async _performTask(job) {
-        const info = job.data;
-        // queue config
-        const queueItem = this.bean.onion.queue.getOnionSlice(info.queueName);
-        const queueConfig = this.bean.onion.queue.getOnionOptions(info.queueName);
-        // execute
-        return await this.bean.executor.newCtx(async () => {
-            const beanFullName = queueItem.beanOptions.beanFullName;
-            const beanInstance = this.app.bean._getBean(beanFullName);
-            return await beanInstance.execute(info.data, info.options, job);
-        }, {
-            dbInfo: info.options?.dbInfo,
-            locale: info.options?.locale,
-            instanceName: info.options?.instanceName,
-            extraData: info.options?.extraData,
-            transaction: queueConfig?.transaction,
-        });
-    }
-    getRepeatKey(jobName, repeat) {
-        const endDate = repeat.endDate ? new Date(repeat.endDate).getTime() : '';
-        const tz = repeat.tz || '';
-        const pattern = repeat.pattern;
-        const suffix = (pattern || String(repeat.every)) || '';
-        return `${jobName}:${endDate}:${tz}:${suffix}`;
-    }
-    prepareJobInfo(queueName, data, options) {
-        options = this.$scope.executor.service.executor.prepareGeneralInfo(options);
-        // info
-        return { queueName, data, options };
-    }
-};
-ServiceQueue = __decorate([
-    Service()
-], ServiceQueue);
-export { ServiceQueue };

package/dist/types/index.js

@@ -1 +0,0 @@
-export * from "./queue.js";

package/dist/types/queue.js

@@ -1 +0,0 @@
-export {};