@midwayjs/bull 3.0.0

package/README.md

@@ -0,0 +1,126 @@
+# @midwayjs/bull
+
+## 简介
+
+midwayjs/bull 是为了能解决任务系列的模块，例如分布式定时任务、延迟任务调度。例如订单2小时后失效、每日定时的数据处理等工作。
+
+## 安装方法
+
+```bash
+tnpm install @midwayjs/bull -S
+```
+
+## 使用方法
+
+在Configuration.ts 导入组件
+
+```typescript
+
+import * as bull from '@midwayjs/bull';
+
+@Configuration({
+  imports: [bull],
+  importConfigs: [
+    join(__dirname, 'config')
+  ]
+})
+export class AutoConfiguration{
+}
+```
+
+配置：
+
+在 config.default.ts 文件中配置对应的模块信息：
+
+```typescript
+export const bull = {
+  defaultQueueOptions: {
+    redis: `redis://127.0.0.1:6379`,
+    prefix: 'midway-task',
+  }
+  defaultJobOptions: {
+    repeat: {
+      tz: "Asia/Shanghai"
+    }
+  }
+}
+```
+
+## 业务代码编写方式
+
+定义一个任务处理器
+
+```typescript
+@Processor('test')
+export class UserServiceProcessor {
+  @Inject()
+  helloService: HelloService;
+
+  async execute(data: any) {
+    console.log(this.helloService.getName());
+
+    // console data
+    console.log(data);
+  }
+}
+```
+
+在需要的地方手动执行
+
+```typescript
+import * as bull from '@midwayjs/bull';
+
+@Configuration({
+  imports: [bull],
+  importConfigs: [
+    join(__dirname, 'config')
+  ]
+})
+export class AutoConfiguration {
+  @Inject()
+  bullFramework: bull.BullFramework;
+
+  async onServerReady() {
+    bullFramework.getQueue('test').runJob({
+      name: 'test'
+    });
+  }
+}
+```
+
+
+定时执行任务：
+
+```typescript
+@Processor('test', {
+  repeat: {
+    cron: '0 0 0 * * *'
+  }
+})
+export class UserServiceProcessor {
+  @Inject()
+  helloService: HelloService;
+
+  async execute(data: any) {
+    console.log(this.helloService.getName());
+
+    // console data
+    console.log(data);
+  }
+}
+```
+
+## 其他
+
+关于task任务的配置：
+```
+*    *    *    *    *    *
+┬    ┬    ┬    ┬    ┬    ┬
+│    │    │    │    │    |
+│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)
+│    │    │    │    └───── month (1 - 12)
+│    │    │    └────────── day of month (1 - 31)
+│    │    └─────────────── hour (0 - 23)
+│    └──────────────────── minute (0 - 59)
+└───────────────────────── second (0 - 59, optional)
+```

package/dist/config/config.default.d.ts

@@ -0,0 +1,16 @@
+export declare const bull: {
+    defaultQueueOptions: {
+        prefix: string;
+    };
+    contextLoggerApplyLogger: string;
+    contextLoggerFormat: (info: any) => string;
+    defaultConcurrency: number;
+};
+export declare const midwayLogger: {
+    clients: {
+        bullLogger: {
+            fileLogName: string;
+        };
+    };
+};
+//# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.midwayLogger = exports.bull = void 0;
+exports.bull = {
+    defaultQueueOptions: {
+        prefix: 'midway-task',
+    },
+    contextLoggerApplyLogger: 'bullLogger',
+    contextLoggerFormat: info => {
+        const { jobId, triggerName } = info.ctx;
+        return `${info.timestamp} ${info.LEVEL} ${info.pid} [${jobId} ${triggerName}] ${info.message}`;
+    },
+    defaultConcurrency: 1,
+};
+exports.midwayLogger = {
+    clients: {
+        bullLogger: {
+            fileLogName: 'midway-bull.log',
+        },
+    },
+};
+//# sourceMappingURL=config.default.js.map

package/dist/configuration.d.ts

@@ -0,0 +1,8 @@
+import { BullFramework } from './framework';
+import { MidwayDecoratorService } from '@midwayjs/core';
+export declare class BullConfiguration {
+    framework: BullFramework;
+    decoratorService: MidwayDecoratorService;
+    init(): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,50 @@
+"use strict";
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullConfiguration = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const DefaultConfig = require("./config/config.default");
+const framework_1 = require("./framework");
+const core_1 = require("@midwayjs/core");
+const constants_1 = require("./constants");
+let BullConfiguration = class BullConfiguration {
+    async init() {
+        this.decoratorService.registerPropertyHandler(constants_1.BULL_QUEUE_KEY, (propertyName, meta) => {
+            return this.framework.getQueue(meta.queueName);
+        });
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", framework_1.BullFramework)
+], BullConfiguration.prototype, "framework", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], BullConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], BullConfiguration.prototype, "init", null);
+BullConfiguration = __decorate([
+    (0, decorator_1.Configuration)({
+        namespace: 'task',
+        importConfigs: [
+            {
+                default: DefaultConfig,
+            },
+        ],
+    })
+], BullConfiguration);
+exports.BullConfiguration = BullConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const BULL_QUEUE_KEY = "bull:queue";
+export declare const BULL_PROCESSOR_KEY = "bull:processor";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BULL_PROCESSOR_KEY = exports.BULL_QUEUE_KEY = void 0;
+// task
+exports.BULL_QUEUE_KEY = 'bull:queue';
+exports.BULL_PROCESSOR_KEY = 'bull:processor';
+// export const BULL_REPEATABLE_PROCESSOR_KEY = 'bull:repeatableProcessor';
+//# sourceMappingURL=constants.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,5 @@
+import { JobOptions } from 'bull';
+export declare function Processor(queueName: string, Options?: JobOptions): ClassDecorator;
+export declare function Processor(queueName: string, concurrency?: number, jobOptions?: JobOptions): ClassDecorator;
+export declare function InjectQueue(queueName: string): PropertyDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectQueue = exports.Processor = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const constants_1 = require("./constants");
+function Processor(queueName, concurrency, jobOptions) {
+    return function (target) {
+        if (typeof concurrency !== 'number') {
+            jobOptions = concurrency;
+            concurrency = 1;
+        }
+        (0, decorator_1.saveModule)(constants_1.BULL_PROCESSOR_KEY, target);
+        (0, decorator_1.saveClassMetadata)(constants_1.BULL_PROCESSOR_KEY, {
+            queueName,
+            concurrency,
+            jobOptions,
+        }, target);
+        (0, decorator_1.Provide)()(target);
+        (0, decorator_1.Scope)(decorator_1.ScopeEnum.Request)(target);
+    };
+}
+exports.Processor = Processor;
+function InjectQueue(queueName) {
+    return (0, decorator_1.createCustomPropertyDecorator)(constants_1.BULL_QUEUE_KEY, {
+        queueName,
+    });
+}
+exports.InjectQueue = InjectQueue;
+//
+// export function Queue(queueOptions?: QueueOptions): ClassDecorator;
+// export function Queue(
+//   queueName?: string,
+//   queueOptions?: QueueOptions
+// ): ClassDecorator;
+// export function Queue(
+//   queueName?: string,
+//   concurrency?: number,
+//   queueOptions?: QueueOptions
+// ): ClassDecorator;
+// export function Queue(
+//   queueName?: any,
+//   concurrency?: any,
+//   queueOptions?: QueueOptions
+// ): ClassDecorator {
+//   return function (target) {
+//     if (typeof queueName !== 'string') {
+//       queueOptions = queueName;
+//       queueName = `${target.name}:execute`;
+//       concurrency = 1;
+//     }
+//     if (typeof concurrency !== 'number') {
+//       queueOptions = concurrency;
+//       concurrency = 1;
+//     }
+//     saveModule(BULL_QUEUE_KEY, target);
+//     saveClassMetadata(
+//       BULL_QUEUE_KEY,
+//       {
+//         queueName,
+//         queueOptions,
+//         concurrency,
+//       },
+//       target
+//     );
+//     Provide()(target);
+//     Scope(ScopeEnum.Singleton)(target);
+//   };
+// }
+//# sourceMappingURL=decorator.js.map

package/dist/framework.d.ts

@@ -0,0 +1,26 @@
+import { BaseFramework, IMidwayBootstrapOptions } from '@midwayjs/core';
+import { Application, Context, IProcessor, IQueue, IQueueManager } from './interface';
+import { Job, JobOptions, QueueOptions } from 'bull';
+import * as Bull from 'bull';
+export declare class BullQueue extends Bull implements IQueue<Job> {
+    constructor(queueName: string, queueOptions: QueueOptions);
+    runJob(data: Record<string, any>, options?: JobOptions): Promise<Job<any>>;
+    getQueueName(): string;
+}
+export declare class BullFramework extends BaseFramework<Application, Context, any> implements IQueueManager<BullQueue, Job> {
+    private bullDefaultQueueConfig;
+    private bullDefaultConcurrency;
+    private queueMap;
+    applicationInitialize(options: IMidwayBootstrapOptions): Promise<void>;
+    configure(): any;
+    getFrameworkName(): string;
+    run(): Promise<void>;
+    protected beforeStop(): Promise<void>;
+    createQueue(name: string, queueOptions?: QueueOptions): BullQueue;
+    getQueue(name: string): BullQueue;
+    ensureQueue(name: string): BullQueue;
+    addProcessor(processor: new (...args: any[]) => IProcessor, queueName: string | BullQueue, concurrency?: number): Promise<void>;
+    runJob(queueName: string, jobData: any, options?: JobOptions): Promise<void>;
+    getJob(queueName: string, jobName: string): Promise<Job>;
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -0,0 +1,113 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullFramework = exports.BullQueue = void 0;
+const core_1 = require("@midwayjs/core");
+const decorator_1 = require("@midwayjs/decorator");
+const Bull = require("bull");
+const constants_1 = require("./constants");
+class BullQueue extends Bull {
+    constructor(queueName, queueOptions) {
+        super(queueName, queueOptions);
+    }
+    async runJob(data, options) {
+        return this.add(data || {}, options);
+    }
+    getQueueName() {
+        return this.name;
+    }
+}
+exports.BullQueue = BullQueue;
+let BullFramework = class BullFramework extends core_1.BaseFramework {
+    constructor() {
+        super(...arguments);
+        this.queueMap = new Map();
+    }
+    async applicationInitialize(options) {
+        this.app = {};
+        this.bullDefaultQueueConfig = this.configService.getConfiguration('bull.defaultQueueOptions');
+        this.bullDefaultConcurrency = this.configService.getConfiguration('bull.defaultConcurrency');
+    }
+    configure() {
+        return this.configService.getConfiguration('bull');
+    }
+    getFrameworkName() {
+        return 'bull';
+    }
+    async run() {
+        var _a;
+        const processorModules = (0, decorator_1.listModule)(constants_1.BULL_PROCESSOR_KEY);
+        for (const mod of processorModules) {
+            const options = (0, decorator_1.getClassMetadata)(constants_1.BULL_PROCESSOR_KEY, mod);
+            this.ensureQueue(options.queueName);
+            await this.addProcessor(mod, options.queueName, options.concurrency);
+            if ((_a = options.jobOptions) === null || _a === void 0 ? void 0 : _a.repeat) {
+                await this.runJob(options.queueName, {}, options.jobOptions);
+            }
+        }
+    }
+    async beforeStop() {
+        // loop queueMap and stop all queue
+        for (const queue of this.queueMap.values()) {
+            await queue.close();
+        }
+    }
+    createQueue(name, queueOptions = {}) {
+        const queue = new BullQueue(name, (0, core_1.extend)(true, this.bullDefaultQueueConfig, queueOptions));
+        this.queueMap.set(name, queue);
+        return queue;
+    }
+    getQueue(name) {
+        return this.queueMap.get(name);
+    }
+    ensureQueue(name) {
+        if (!this.queueMap.has(name)) {
+            this.createQueue(name);
+        }
+        return this.queueMap.get(name);
+    }
+    async addProcessor(processor, queueName, concurrency) {
+        const queue = typeof queueName === 'string' ? this.queueMap.get(queueName) : queueName;
+        queue.process(concurrency !== null && concurrency !== void 0 ? concurrency : this.bullDefaultConcurrency, async (job) => {
+            const ctx = this.app.createAnonymousContext({
+                jobId: job.id,
+                job,
+                triggerName: (0, decorator_1.getProviderName)(processor),
+                triggerUUID: (0, decorator_1.getProviderUUId)(processor),
+            });
+            const service = await ctx.requestContext.getAsync(processor);
+            const fn = await this.applyMiddleware(async (ctx) => {
+                return await decorator_1.Utils.toAsyncFunction(service.execute.bind(service))(job.data, job);
+            });
+            try {
+                return Promise.resolve(await fn(ctx));
+            }
+            catch (err) {
+                ctx.logger.error(err);
+                return Promise.reject(err);
+            }
+        });
+    }
+    async runJob(queueName, jobData, options) {
+        const queue = this.queueMap.get(queueName);
+        if (queue) {
+            await queue.runJob(jobData, options);
+        }
+    }
+    async getJob(queueName, jobName) {
+        const queue = this.queueMap.get(queueName);
+        if (queue) {
+            return queue.getJob(jobName);
+        }
+    }
+};
+BullFramework = __decorate([
+    (0, decorator_1.Framework)()
+], BullFramework);
+exports.BullFramework = BullFramework;
+//# sourceMappingURL=framework.js.map

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { BullConfiguration as Configuration } from './configuration';
+export { BullFramework as Framework } from './framework';
+export * from './decorator';
+export * from './interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Framework = exports.Configuration = void 0;
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.BullConfiguration; } });
+var framework_1 = require("./framework");
+Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return framework_1.BullFramework; } });
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,26 @@
+import { IMidwayApplication, IMidwayContext, NextFunction as BaseNextFunction } from '@midwayjs/core';
+import { JobId, Job } from 'bull';
+export interface IProcessor {
+    execute(data: any): any;
+}
+export interface IQueue<Job> {
+    runJob(data: Record<string, any>, options?: unknown): any;
+    getJob(name: string): Promise<Job>;
+    getQueueName(): string;
+}
+export interface IQueueManager<Queue extends IQueue<Job>, Job> {
+    runJob(queueName: string, jobData: any, options?: unknown): any;
+    getJob(queueName: string, jobName: string): Promise<Job>;
+    createQueue(queueName: string, queueOptions?: unknown): Queue;
+    getQueue(queueName: string): Queue;
+}
+export interface Application extends IMidwayApplication<Context> {
+}
+export declare type NextFunction = BaseNextFunction;
+export interface Context extends IMidwayContext {
+    jobId: JobId;
+    job: Job;
+    triggerName: string;
+    triggerUUID: string;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/index.d.ts

@@ -0,0 +1,13 @@
+import * as bull from 'bull';
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  // eslint-disable-next-line
+  interface MidwayConfig {
+    bull?: {
+      defaultQueueOptions?: bull.QueueOptions;
+      defaultJobOptions?: bull.JobOptions;
+      defaultConcurrency?: number;
+    };
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@midwayjs/bull",
+  "version": "3.0.0",
+  "description": "midway component for bull",
+  "main": "dist/index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit"
+  },
+  "keywords": [
+    "midway",
+    "IoC",
+    "task",
+    "bull",
+    "plugin"
+  ],
+  "author": "",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@midwayjs/core": "^3.4.13",
+    "@midwayjs/decorator": "^3.4.11",
+    "@midwayjs/mock": "^3.4.13"
+  },
+  "dependencies": {
+    "bull": "4.8.5",
+    "@types/bull": "3.15.9"
+  },
+  "engines": {
+    "node": ">=12"
+  }
+}