@midwayjs/cron 3.0.0

package/README.md

@@ -0,0 +1,12 @@
+# midwayjs cron module
+
+[![Package Quality](http://npm.packagequality.com/shield/midway-core.svg)](http://packagequality.com/#?package=midway-core)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/midwayjs/midway/pulls)
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

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

package/dist/configuration.js

@@ -0,0 +1,67 @@
+"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.CronConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const framework_1 = require("./framework");
+const constants_1 = require("./constants");
+let CronConfiguration = class CronConfiguration {
+    async init() {
+        this.decoratorService.registerPropertyHandler(constants_1.CRON_JOB_KEY, (propertyName, meta) => {
+            return this.framework.getJob(meta.jobName);
+        });
+    }
+    async onReady() {
+        this.framework.loadConfig();
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", framework_1.CronFramework)
+], CronConfiguration.prototype, "framework", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], CronConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CronConfiguration.prototype, "init", null);
+CronConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'cron',
+        importConfigs: [
+            {
+                default: {
+                    cron: {
+                        defaultCronJobOptions: {},
+                        contextLoggerApplyLogger: 'cronLogger',
+                    },
+                    midwayLogger: {
+                        clients: {
+                            cronLogger: {
+                                fileLogName: 'midway-cron.log',
+                                contextFormat: info => {
+                                    const { jobId, from } = info.ctx;
+                                    return `${info.timestamp} ${info.LEVEL} ${info.pid} [${jobId} ${from.name}}] ${info.message}`;
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+    })
+], CronConfiguration);
+exports.CronConfiguration = CronConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CRON_JOB_KEY = "cron:job";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRON_JOB_KEY = void 0;
+// task
+exports.CRON_JOB_KEY = 'cron:job';
+//# sourceMappingURL=constants.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,5 @@
+import { CronJobOptions, IJob } from './interface';
+export declare function Job(jobOptions?: CronJobOptions): ClassDecorator;
+export declare function Job(jobName: string, jobOptions?: CronJobOptions): ClassDecorator;
+export declare function InjectJob(jobName: string | (new (...args: any[]) => IJob)): PropertyDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectJob = exports.Job = void 0;
+const core_1 = require("@midwayjs/core");
+const constants_1 = require("./constants");
+function Job(jobName, jobOptions) {
+    return function (target) {
+        if (typeof jobName !== 'string') {
+            jobOptions = jobName;
+            jobName = undefined;
+        }
+        (0, core_1.saveModule)(constants_1.CRON_JOB_KEY, target);
+        (0, core_1.saveClassMetadata)(constants_1.CRON_JOB_KEY, {
+            jobOptions,
+            jobName,
+        }, target);
+        (0, core_1.Provide)()(target);
+        (0, core_1.Scope)(core_1.ScopeEnum.Request)(target);
+    };
+}
+exports.Job = Job;
+function InjectJob(jobName) {
+    return (0, core_1.createCustomPropertyDecorator)(constants_1.CRON_JOB_KEY, {
+        jobName,
+    });
+}
+exports.InjectJob = InjectJob;
+//# sourceMappingURL=decorator.js.map

package/dist/framework.d.ts

@@ -0,0 +1,18 @@
+import { BaseFramework, IMidwayBootstrapOptions } from '@midwayjs/core';
+import { Application, Context, JobNameOrClz } from './interface';
+import { CronJob, CronJobParameters } from 'cron';
+export declare class CronFramework extends BaseFramework<Application, Context, any> {
+    private defaultCronJobConfig;
+    private jobs;
+    applicationInitialize(options: IMidwayBootstrapOptions): Promise<void>;
+    loadConfig(): void;
+    configure(): any;
+    getFrameworkName(): string;
+    run(): Promise<void>;
+    protected beforeStop(): Promise<void>;
+    addJob(name: JobNameOrClz, jobOptions?: Partial<CronJobParameters>): CronJob;
+    getJob(name: JobNameOrClz): CronJob;
+    deleteJob(name: JobNameOrClz): Promise<void>;
+    private getJobName;
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -0,0 +1,115 @@
+"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.CronFramework = void 0;
+const core_1 = require("@midwayjs/core");
+const cron_1 = require("cron");
+const constants_1 = require("./constants");
+let CronFramework = class CronFramework extends core_1.BaseFramework {
+    constructor() {
+        super(...arguments);
+        this.jobs = new Map();
+    }
+    async applicationInitialize(options) {
+        this.app = {};
+    }
+    loadConfig() {
+        this.defaultCronJobConfig = this.configService.getConfiguration('cron.defaultCronJobOptions');
+    }
+    configure() {
+        return this.configService.getConfiguration('cron');
+    }
+    getFrameworkName() {
+        return 'cron';
+    }
+    async run() {
+        const jobModules = (0, core_1.listModule)(constants_1.CRON_JOB_KEY);
+        for (const mod of jobModules) {
+            this.addJob(mod);
+        }
+    }
+    async beforeStop() {
+        // loop queueMap and stop all queue
+        for (const name of this.jobs.keys()) {
+            await this.deleteJob(name);
+        }
+    }
+    addJob(name, jobOptions = {}) {
+        let jobName;
+        if (typeof name === 'string') {
+            jobName = name;
+        }
+        else {
+            const options = (0, core_1.getClassMetadata)(constants_1.CRON_JOB_KEY, name);
+            jobName = options.name || (0, core_1.getProviderUUId)(name);
+            jobOptions = (0, core_1.extend)(true, {}, this.defaultCronJobConfig, options.jobOptions, jobOptions);
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const self = this;
+            jobOptions.onTick = function () {
+                (async () => {
+                    var _a;
+                    const ctx = self.app.createAnonymousContext({
+                        job: this,
+                    });
+                    ctx.logger.info(`start job ${name.name}`);
+                    const isPassed = await self.app
+                        .getFramework()
+                        .runGuard(ctx, name, 'onTick');
+                    if (!isPassed) {
+                        throw new core_1.MidwayInvokeForbiddenError('onTick', name);
+                    }
+                    const service = await ctx.requestContext.getAsync(name);
+                    const fn = await self.applyMiddleware(async (ctx) => {
+                        return await core_1.Utils.toAsyncFunction(service.onTick.bind(service))();
+                    });
+                    try {
+                        const result = await Promise.resolve(await fn(ctx));
+                        ctx.logger.info(`complete job ${name.name}`);
+                        await ((_a = service.onComplete) === null || _a === void 0 ? void 0 : _a.call(service, result));
+                        return result;
+                    }
+                    catch (err) {
+                        ctx.logger.error(err);
+                    }
+                })().catch(err => {
+                    self.logger.error(`error in job from ${name.name}: ${err}`);
+                });
+            };
+        }
+        const job = new cron_1.CronJob(jobOptions);
+        this.jobs.set(jobName, job);
+        return job;
+    }
+    getJob(name) {
+        return this.jobs.get(this.getJobName(name));
+    }
+    async deleteJob(name) {
+        const jobName = this.getJobName(name);
+        try {
+            this.jobs.get(jobName).stop();
+            this.jobs.delete(jobName);
+        }
+        catch (err) {
+            this.logger.error(`error in trying to stop job: ${jobName}: ${err}`);
+        }
+    }
+    getJobName(name) {
+        if (typeof name === 'string') {
+            return name;
+        }
+        else {
+            const options = (0, core_1.getClassMetadata)(constants_1.CRON_JOB_KEY, name);
+            return options.name || (0, core_1.getProviderUUId)(name);
+        }
+    }
+};
+CronFramework = __decorate([
+    (0, core_1.Framework)()
+], CronFramework);
+exports.CronFramework = CronFramework;
+//# sourceMappingURL=framework.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,25 @@
+"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;
+__exportStar(require("./interface"), exports);
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.CronConfiguration; } });
+var framework_1 = require("./framework");
+Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return framework_1.CronFramework; } });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./decorator"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,25 @@
+import { IMidwayApplication, IMidwayContext, NextFunction as BaseNextFunction } from '@midwayjs/core';
+import { CronJob, CronJobParameters } from 'cron';
+export { CronJob } from 'cron';
+export type CronJobOptions = Omit<CronJobParameters, 'onTick' | 'onComplete'>;
+export interface CronOptions {
+    defaultCronJobOptions?: CronJobOptions;
+}
+export interface IJob {
+    /**
+     * The function to fire at the specified time. If an onComplete callback was provided, onTick will receive it as an argument. onTick may call onComplete when it has finished its work.
+     */
+    onTick(data: any): any;
+    /**
+     * A function that will fire when the job is stopped with job.stop(), and may also be called by onTick at the end of each run.
+     */
+    onComplete?(result: any): any;
+}
+export type JobNameOrClz = string | (new (...args: any[]) => IJob);
+export interface Application extends IMidwayApplication<Context> {
+}
+export type NextFunction = BaseNextFunction;
+export interface Context extends IMidwayContext {
+    job: CronJob;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJob = void 0;
+var cron_1 = require("cron");
+Object.defineProperty(exports, "CronJob", { enumerable: true, get: function () { return cron_1.CronJob; } });
+//# sourceMappingURL=interface.js.map

package/index.d.ts

@@ -0,0 +1,8 @@
+import { CronOptions } from './dist/index';
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    cron?: Partial<CronOptions>;
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@midwayjs/cron",
+  "version": "3.0.0",
+  "description": "Midway Component for Cron",
+  "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",
+    "ci": "npm run test"
+  },
+  "keywords": [
+    "midway",
+    "component",
+    "cron"
+  ],
+  "author": "Harry Chen <czy88840616@gmail.com>",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "engines": {
+    "node": ">=12"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "cron": "2.2.0",
+    "@types/cron": "2.0.0"
+  },
+  "devDependencies": {
+    "@midwayjs/core": "^3.10.10",
+    "@midwayjs/mock": "^3.10.13"
+  }
+}