@orion-js/dogs 3.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Orionjs Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/defineJob/index.d.ts

@@ -0,0 +1,2 @@
+import { JobDefinition } from '../types/JobsDefinition';
+export declare const defineJob: (options: JobDefinition) => JobDefinition;

package/lib/defineJob/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineJob = void 0;
+const defineJob = (options) => {
+    return options;
+};
+exports.defineJob = defineJob;

package/lib/events.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/events.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const helpers_1 = require("@orion-js/helpers");
+const _1 = require(".");
+describe('Event tests', () => {
+    it('Should run an event job', async () => {
+        let count = 0;
+        const job3 = (0, _1.defineJob)({
+            type: 'event',
+            async resolve(params) {
+                count += params.add;
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { job3 },
+            workersCount: 1,
+            pollInterval: 10,
+            cooldownPeriod: 10,
+            logLevel: 'info'
+        });
+        expect(count).toBe(0);
+        await (0, _1.scheduleJob)({
+            name: 'job3',
+            params: { add: 5 },
+            runIn: 1
+        });
+        await (0, _1.scheduleJob)({
+            name: 'job3',
+            params: { add: 25 },
+            runIn: 1
+        });
+        await (0, helpers_1.sleep)(100);
+        await instance.stop();
+        expect(count).toBe(30);
+    });
+    it('Should run retry the job 3 times', async () => {
+        let passes = false;
+        const job4 = (0, _1.defineJob)({
+            type: 'event',
+            async resolve(params, context) {
+                if (context.tries < 3) {
+                    throw new Error('Failed');
+                }
+                passes = true;
+            },
+            async onError() {
+                return {
+                    action: 'retry',
+                    runIn: 1
+                };
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { job4 },
+            workersCount: 1,
+            pollInterval: 10,
+            cooldownPeriod: 10,
+            logLevel: 'info'
+        });
+        expect(passes).toBe(false);
+        await (0, _1.scheduleJob)({
+            name: 'job4',
+            runIn: 1
+        });
+        await (0, helpers_1.sleep)(100);
+        await instance.stop();
+        expect(passes).toBe(true);
+    });
+    it('Should throw locktime error and test extendLockTime', async () => {
+        const jobId = (0, helpers_1.generateId)();
+        let ranCount = 0;
+        let staleCount = 0;
+        const job = (0, _1.defineJob)({
+            type: 'event',
+            async resolve(params, context) {
+                if (ranCount === 1) {
+                    expect(context.tries).toBe(2);
+                    context.extendLockTime(10000);
+                }
+                await (0, helpers_1.sleep)(100);
+                ranCount++;
+            },
+            async onStale(params, context) {
+                expect(context.tries).toBe(1);
+                staleCount++;
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobId]: job },
+            workersCount: 1,
+            pollInterval: 10,
+            cooldownPeriod: 10,
+            lockTime: 40,
+            logLevel: 'info'
+        });
+        await (0, _1.scheduleJob)({
+            name: jobId,
+            runIn: 1
+        });
+        await (0, helpers_1.sleep)(200);
+        await instance.stop();
+        expect(ranCount).toBe(2);
+        expect(staleCount).toBe(1);
+    });
+    it('Should only schedule one job with uniqueIdentifier', async () => {
+        const jobId = (0, helpers_1.generateId)();
+        let ranCount = 0;
+        const job = (0, _1.defineJob)({
+            type: 'event',
+            async resolve() {
+                ranCount++;
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobId]: job },
+            workersCount: 1,
+            pollInterval: 10,
+            cooldownPeriod: 10,
+            logLevel: 'warn'
+        });
+        await (0, _1.scheduleJob)({
+            name: jobId,
+            runIn: 1,
+            uniqueIdentifier: 'unique'
+        });
+        await (0, _1.scheduleJob)({
+            name: jobId,
+            runIn: 1,
+            uniqueIdentifier: 'unique'
+        });
+        await (0, helpers_1.sleep)(50);
+        await instance.stop();
+        expect(ranCount).toBe(1);
+    });
+});

package/lib/history.test.d.ts

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

package/lib/history.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const _1 = require(".");
+describe('Test Jobs History', () => {
+    it('Should save success history types', async () => {
+        const jobId = (0, helpers_1.generateId)();
+        const job = (0, _1.defineJob)({
+            type: 'event',
+            async resolve() {
+                await (0, helpers_1.sleep)(50);
+                return {
+                    number: 1
+                };
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobId]: job },
+            workersCount: 1,
+            pollInterval: 10
+        });
+        await (0, _1.scheduleJob)({
+            name: jobId,
+            runIn: 1,
+            params: { id: 2 }
+        });
+        await (0, helpers_1.sleep)(100);
+        await instance.stop();
+        const executions = await _1.jobsHistory.getExecutions(jobId);
+        expect(executions.length).toBe(1);
+        const execution = executions[0];
+        expect(execution.duration).toBeGreaterThan(49);
+        expect(execution).toEqual({
+            _id: expect.any(String),
+            executionId: expect.any(String),
+            jobName: jobId,
+            isRecurrent: false,
+            priority: 1,
+            tries: 1,
+            startedAt: expect.any(Date),
+            endedAt: expect.any(Date),
+            duration: expect.any(Number),
+            expiresAt: expect.any(Date),
+            status: 'success',
+            errorMessage: null,
+            params: { id: 2 },
+            result: { number: 1 }
+        });
+    });
+    it('Should save error history types', async () => {
+        const jobId = (0, helpers_1.generateId)();
+        const job = (0, _1.defineJob)({
+            type: 'event',
+            async resolve() {
+                throw new Error('Hello');
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobId]: job },
+            workersCount: 1,
+            pollInterval: 10,
+            logLevel: 'none'
+        });
+        await (0, _1.scheduleJob)({
+            name: jobId,
+            runIn: 1,
+            params: { id: 4 }
+        });
+        await (0, helpers_1.sleep)(100);
+        await instance.stop();
+        const executions = await _1.jobsHistory.getExecutions(jobId);
+        expect(executions.length).toBe(1);
+        const execution = executions[0];
+        expect(execution).toEqual({
+            _id: expect.any(String),
+            executionId: expect.any(String),
+            jobName: jobId,
+            isRecurrent: false,
+            priority: 1,
+            tries: 1,
+            startedAt: expect.any(Date),
+            endedAt: expect.any(Date),
+            duration: expect.any(Number),
+            expiresAt: expect.any(Date),
+            status: 'error',
+            errorMessage: 'Hello',
+            params: { id: 4 },
+            result: null
+        });
+    });
+    it('Should save stale history types', async () => {
+        const jobId = (0, helpers_1.generateId)();
+        const job = (0, _1.defineJob)({
+            type: 'event',
+            async resolve() {
+                await (0, helpers_1.sleep)(100);
+                return { status: 'ok' };
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobId]: job },
+            workersCount: 1,
+            pollInterval: 10,
+            lockTime: 10,
+            logLevel: 'none'
+        });
+        await (0, _1.scheduleJob)({
+            name: jobId,
+            runIn: 1
+        });
+        await (0, helpers_1.sleep)(150);
+        await instance.stop();
+        const executions = await _1.jobsHistory.getExecutions(jobId);
+        expect(executions.length).toBe(2);
+        const execution1 = executions[1];
+        expect(execution1.duration).toBeGreaterThanOrEqual(10);
+        expect(execution1.duration).toBeLessThan(100);
+        expect(execution1).toEqual({
+            _id: expect.any(String),
+            executionId: expect.any(String),
+            jobName: jobId,
+            isRecurrent: false,
+            priority: 1,
+            tries: 1,
+            startedAt: expect.any(Date),
+            endedAt: expect.any(Date),
+            duration: expect.any(Number),
+            expiresAt: expect.any(Date),
+            status: 'stale',
+            errorMessage: null,
+            params: null,
+            result: null
+        });
+        const execution2 = executions[0];
+        expect(execution2.duration).toBeGreaterThanOrEqual(100);
+        expect(execution2).toEqual({
+            _id: expect.any(String),
+            executionId: expect.any(String),
+            jobName: jobId,
+            isRecurrent: false,
+            priority: 1,
+            tries: 1,
+            startedAt: expect.any(Date),
+            endedAt: expect.any(Date),
+            duration: expect.any(Number),
+            expiresAt: expect.any(Date),
+            status: 'success',
+            errorMessage: null,
+            params: null,
+            result: { status: 'ok' }
+        });
+    });
+});

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import { defineJob } from './defineJob';
+import { StartWorkersConfig } from './types/StartConfig';
+import { ScheduleJobOptions } from './types/Events';
+import { JobsHistoryRepo } from './repos/JobsHistoryRepo';
+declare const jobsHistory: JobsHistoryRepo;
+declare const startWorkers: (config: Partial<StartWorkersConfig>) => import("./types/Worker").WorkersInstance;
+declare const scheduleJob: (options: ScheduleJobOptions) => Promise<void>;
+export { defineJob, startWorkers, scheduleJob, jobsHistory };

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobsHistory = exports.scheduleJob = exports.startWorkers = exports.defineJob = void 0;
+const services_1 = require("@orion-js/services");
+const defineJob_1 = require("./defineJob");
+Object.defineProperty(exports, "defineJob", { enumerable: true, get: function () { return defineJob_1.defineJob; } });
+const EventsService_1 = require("./services/EventsService");
+const WorkerService_1 = require("./services/WorkerService");
+const JobsHistoryRepo_1 = require("./repos/JobsHistoryRepo");
+const workerService = (0, services_1.getInstance)(WorkerService_1.WorkerService);
+const eventsService = (0, services_1.getInstance)(EventsService_1.EventsService);
+const jobsHistory = (0, services_1.getInstance)(JobsHistoryRepo_1.JobsHistoryRepo);
+exports.jobsHistory = jobsHistory;
+const startWorkers = (config) => {
+    return workerService.startWorkers(config);
+};
+exports.startWorkers = startWorkers;
+const scheduleJob = (options) => {
+    return eventsService.scheduleJob(options);
+};
+exports.scheduleJob = scheduleJob;

package/lib/log/index.d.ts

@@ -0,0 +1,5 @@
+import { LogLevels } from '../types/StartConfig';
+export declare let appLogLevel: LogLevels;
+export declare const levelToInt: (level: LogLevels) => 0 | 1 | 2 | 3;
+export declare const log: (level: LogLevels, ...args: any[]) => void;
+export declare const setLogLevel: (level: LogLevels) => void;

package/lib/log/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLogLevel = exports.log = exports.levelToInt = exports.appLogLevel = void 0;
+exports.appLogLevel = 'info';
+const levelToInt = (level) => {
+    switch (level) {
+        case 'debug':
+            return 0;
+        case 'info':
+            return 1;
+        case 'warn':
+            return 2;
+        case 'error':
+            return 3;
+    }
+};
+exports.levelToInt = levelToInt;
+const log = (level, ...args) => {
+    if (exports.appLogLevel === 'none')
+        return;
+    const levelInt = (0, exports.levelToInt)(level);
+    const appLogLevelInt = (0, exports.levelToInt)(exports.appLogLevel);
+    if (levelInt < appLogLevelInt)
+        return;
+    console[level](...args);
+};
+exports.log = log;
+const setLogLevel = (level) => {
+    exports.appLogLevel = level;
+};
+exports.setLogLevel = setLogLevel;

package/lib/recurrent.test.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/lib/recurrent.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const helpers_1 = require("@orion-js/helpers");
+const _1 = require(".");
+describe('Recurrent tests', () => {
+    it('Should run a recurrent job', async () => {
+        let ran = false;
+        const job1 = (0, _1.defineJob)({
+            type: 'recurrent',
+            runEvery: 1000,
+            async resolve() {
+                ran = true;
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { job1 },
+            workersCount: 1,
+            pollInterval: 100,
+            cooldownPeriod: 100,
+            logLevel: 'info'
+        });
+        await (0, helpers_1.sleep)(500);
+        await instance.stop();
+        expect(ran).toBe(true);
+    });
+    it('Should run a recurrent job 3 times', async () => {
+        let count = 0;
+        const job2 = (0, _1.defineJob)({
+            type: 'recurrent',
+            runEvery: 20,
+            async resolve() {
+                count++;
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { job2 },
+            workersCount: 1,
+            pollInterval: 10,
+            cooldownPeriod: 10,
+            logLevel: 'info'
+        });
+        await (0, helpers_1.sleep)(200);
+        await instance.stop();
+        expect(count).toBeGreaterThanOrEqual(3);
+    });
+});

package/lib/repos/JobsHistoryRepo.d.ts

@@ -0,0 +1,7 @@
+import { ModelToDocumentTypeWithoutId } from '@orion-js/mongodb';
+import { HistoryRecord } from '../types/HistoryRecord';
+export declare class JobsHistoryRepo {
+    private history;
+    saveExecution(record: ModelToDocumentTypeWithoutId<HistoryRecord>): Promise<void>;
+    getExecutions(jobName: string, limit?: number, skip?: number): Promise<HistoryRecord[]>;
+}

package/lib/repos/JobsHistoryRepo.js

@@ -0,0 +1,53 @@
+"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.JobsHistoryRepo = void 0;
+const mongodb_1 = require("@orion-js/mongodb");
+const services_1 = require("@orion-js/services");
+const HistoryRecord_1 = require("../types/HistoryRecord");
+let JobsHistoryRepo = class JobsHistoryRepo {
+    constructor() {
+        this.history = (0, mongodb_1.createCollection)({
+            name: 'orionjs.jobs_dogs_history',
+            model: HistoryRecord_1.HistoryRecord,
+            indexes: [
+                {
+                    keys: {
+                        jobName: 1,
+                        startedAt: 1
+                    }
+                },
+                {
+                    keys: {
+                        expiresAt: 1
+                    },
+                    options: {
+                        expireAfterSeconds: 0
+                    }
+                }
+            ]
+        });
+    }
+    async saveExecution(record) {
+        await this.history.insertOne(record);
+    }
+    async getExecutions(jobName, limit, skip) {
+        const cursor = this.history.find({ jobName }).sort({ startedAt: -1 });
+        if (skip) {
+            cursor.skip(skip);
+        }
+        if (limit) {
+            cursor.limit(limit);
+        }
+        return await cursor.toArray();
+    }
+};
+JobsHistoryRepo = __decorate([
+    (0, services_1.Service)()
+], JobsHistoryRepo);
+exports.JobsHistoryRepo = JobsHistoryRepo;

package/lib/repos/JobsRepo.d.ts

@@ -0,0 +1,15 @@
+import { ScheduleJobRecordOptions } from '../types/Events';
+import { JobDefinitionWithName } from '../types/JobsDefinition';
+import { JobToRun } from '../types/Worker';
+export declare class JobsRepo {
+    private jobs;
+    getJobAndLock(jobNames: string[], lockTime: number): Promise<JobToRun>;
+    scheduleNextRun(options: {
+        jobId: string;
+        nextRunAt: Date;
+        addTries: boolean;
+    }): Promise<void>;
+    extendLockTime(jobId: string, extraTime: number): Promise<void>;
+    ensureJobRecord(job: JobDefinitionWithName): Promise<void>;
+    scheduleJob(options: ScheduleJobRecordOptions): Promise<void>;
+}

package/lib/repos/JobsRepo.js

@@ -0,0 +1,146 @@
+"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.JobsRepo = void 0;
+const mongodb_1 = require("@orion-js/mongodb");
+const services_1 = require("@orion-js/services");
+const log_1 = require("../log");
+const JobRecord_1 = require("../types/JobRecord");
+let JobsRepo = class JobsRepo {
+    constructor() {
+        this.jobs = (0, mongodb_1.createCollection)({
+            name: 'orionjs.jobs_dogs_records',
+            model: JobRecord_1.JobRecord,
+            indexes: [
+                {
+                    keys: {
+                        jobName: 1,
+                        nextRunAt: 1,
+                        priority: 1,
+                        lockedUntil: 1
+                    }
+                },
+                {
+                    keys: {
+                        jobName: 1
+                    },
+                    options: {
+                        unique: true,
+                        partialFilterExpression: { isRecurrent: true }
+                    }
+                },
+                {
+                    keys: {
+                        uniqueIdentifier: 1
+                    },
+                    options: {
+                        unique: true,
+                        sparse: true
+                    }
+                }
+            ]
+        });
+    }
+    async getJobAndLock(jobNames, lockTime) {
+        const lockedUntil = new Date(Date.now() + lockTime);
+        const job = await this.jobs.findOneAndUpdate({
+            jobName: { $in: jobNames },
+            nextRunAt: { $lte: new Date() },
+            $or: [{ lockedUntil: { $exists: false } }, { lockedUntil: { $lte: new Date() } }]
+        }, {
+            $set: { lockedUntil }
+        }, {
+            mongoOptions: {
+                sort: {
+                    priority: 1,
+                    nextRunAt: 1
+                },
+                returnDocument: 'before'
+            }
+        });
+        if (!job)
+            return;
+        let tries = job.tries || 1;
+        if (job.lockedUntil) {
+            (0, log_1.log)('debug', `Running job "${job.jobName}" that was staled`);
+            this.jobs.updateOne(job._id, { $inc: { tries: 1 } });
+            tries++;
+        }
+        return {
+            jobId: job._id,
+            name: job.jobName,
+            params: job.params,
+            isRecurrent: job.isRecurrent,
+            tries,
+            lockTime,
+            priority: job.priority,
+            uniqueIdentifier: job.uniqueIdentifier
+        };
+    }
+    async scheduleNextRun(options) {
+        const updator = {
+            $set: { nextRunAt: options.nextRunAt },
+            $unset: { lockedUntil: '' }
+        };
+        if (options.addTries) {
+            updator.$inc = { tries: 1 };
+        }
+        await this.jobs.updateOne(options.jobId, updator);
+    }
+    async extendLockTime(jobId, extraTime) {
+        const lockedUntil = new Date(Date.now() + extraTime);
+        await this.jobs.updateOne({
+            _id: jobId
+        }, {
+            $set: { lockedUntil }
+        });
+    }
+    async ensureJobRecord(job) {
+        const result = await this.jobs.upsert({
+            jobName: job.name
+        }, {
+            $set: {
+                isRecurrent: true,
+                priority: job.priority || 1
+            },
+            $setOnInsert: {
+                nextRunAt: new Date()
+            }
+        });
+        if (result.upsertedId) {
+            (0, log_1.log)('debug', `Created job record for "${job.name}"`);
+        }
+        else {
+            (0, log_1.log)('debug', `Record for job "${job.name}" already exists`);
+        }
+    }
+    async scheduleJob(options) {
+        try {
+            await this.jobs.insertOne({
+                jobName: options.name,
+                uniqueIdentifier: options.uniqueIdentifier,
+                params: options.params,
+                nextRunAt: options.nextRunAt,
+                priority: options.priority,
+                isRecurrent: false
+            });
+        }
+        catch (error) {
+            if (error.code === 11000 && options.uniqueIdentifier) {
+                (0, log_1.log)('info', `Job "${options.name}" with identifier "${options.uniqueIdentifier}" already exists`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+};
+JobsRepo = __decorate([
+    (0, services_1.Service)()
+], JobsRepo);
+exports.JobsRepo = JobsRepo;

package/lib/services/EventsService.d.ts

@@ -0,0 +1,5 @@
+import { ScheduleJobOptions } from '../types/Events';
+export declare class EventsService {
+    private jobsRepo;
+    scheduleJob(options: ScheduleJobOptions): Promise<void>;
+}