@orion-js/dogs 3.12.0 → 3.13.1

package/lib/service/index.d.ts

@@ -0,0 +1,10 @@
+import { EventJobDefinition, JobDefinition, RecurrentJobDefinition } from '../types';
+export declare function Jobs(): ClassDecorator;
+export interface JobsPropertyDescriptor extends Omit<PropertyDecorator, 'value'> {
+    value?: JobDefinition['resolve'];
+}
+export declare function RecurrentJob(options: Omit<RecurrentJobDefinition, 'resolve' | 'type'>): (target: any, propertyKey: string, descriptor: JobsPropertyDescriptor) => void;
+export declare function EventJob(options?: Omit<EventJobDefinition, 'resolve' | 'type'>): (target: any, propertyKey: string, descriptor: JobsPropertyDescriptor) => void;
+export declare function getServiceJobs(target: any): {
+    [key: string]: JobDefinition;
+};

package/lib/service/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jobs = Jobs;
+exports.RecurrentJob = RecurrentJob;
+exports.EventJob = EventJob;
+exports.getServiceJobs = getServiceJobs;
+const services_1 = require("@orion-js/services");
+const defineJob_1 = require("../defineJob");
+function Jobs() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+    };
+}
+function RecurrentJob(options) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, defineJob_1.defineJob)({
+            ...options,
+            type: 'recurrent',
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+function EventJob(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (!descriptor.value)
+            throw new Error(`You must pass resolver function to ${propertyKey}`);
+        target.echoes = target.echoes || {};
+        target.echoes[propertyKey] = (0, defineJob_1.defineJob)({
+            ...options,
+            type: 'event',
+            resolve: async (params, viewer) => {
+                const instance = (0, services_1.getInstance)(target.service);
+                return await instance[propertyKey](params, viewer);
+            }
+        });
+    };
+}
+function getServiceJobs(target) {
+    if (!target.prototype) {
+        throw new Error('You must pass a class to getServiceRoutes');
+    }
+    return target.prototype.echoes || {};
+}

package/lib/service/index.test.d.ts

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

package/lib/service/index.test.js

@@ -0,0 +1,51 @@
+"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 });
+const _1 = require(".");
+describe('Jobs (dogs) with service injections', () => {
+    it('Should define a jobs map using services', async () => {
+        let ExampleJobsService = class ExampleJobsService {
+            async job1() {
+                return {};
+            }
+            async job2() {
+                return {};
+            }
+        };
+        __decorate([
+            (0, _1.EventJob)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleJobsService.prototype, "job1", null);
+        __decorate([
+            (0, _1.RecurrentJob)({ runEvery: 1000 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ExampleJobsService.prototype, "job2", null);
+        ExampleJobsService = __decorate([
+            (0, _1.Jobs)()
+        ], ExampleJobsService);
+        const jobs = (0, _1.getServiceJobs)(ExampleJobsService);
+        expect(jobs).toMatchObject({
+            job1: {
+                type: 'event',
+                resolve: expect.any(Function)
+            },
+            job2: {
+                type: 'recurrent',
+                runEvery: 1000,
+                resolve: expect.any(Function)
+            }
+        });
+    });
+});

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>;
+}

package/lib/services/EventsService.js

@@ -0,0 +1,36 @@
+"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.EventsService = void 0;
+const logger_1 = require("@orion-js/logger");
+const services_1 = require("@orion-js/services");
+const JobsRepo_1 = require("../repos/JobsRepo");
+const getNextRunDate_1 = require("./getNextRunDate");
+let EventsService = class EventsService {
+    async scheduleJob(options) {
+        logger_1.logger.debug('Scheduling job...', options);
+        await this.jobsRepo.scheduleJob({
+            name: options.name,
+            priority: options.priority || 100,
+            nextRunAt: (0, getNextRunDate_1.getNextRunDate)(options),
+            params: options.params || null,
+            uniqueIdentifier: options.uniqueIdentifier
+        });
+    }
+};
+exports.EventsService = EventsService;
+__decorate([
+    (0, services_1.Inject)(),
+    __metadata("design:type", JobsRepo_1.JobsRepo)
+], EventsService.prototype, "jobsRepo", void 0);
+exports.EventsService = EventsService = __decorate([
+    (0, services_1.Service)()
+], EventsService);

package/lib/services/Executor.d.ts

@@ -0,0 +1,20 @@
+import { PlainObject } from '../types/HistoryRecord';
+import { JobDefinition, JobsDefinition } from '../types/JobsDefinition';
+import { ExecutionContext, JobToRun } from '../types/Worker';
+export declare class Executor {
+    private readonly jobsRepo;
+    private readonly jobsHistoryRepo;
+    getContext(job: JobDefinition, jobToRun: JobToRun, onStale: Function): ExecutionContext;
+    getJobDefinition(jobToRun: JobToRun, jobs: JobsDefinition): JobDefinition;
+    onError(error: any, job: JobDefinition, jobToRun: JobToRun, context: ExecutionContext): Promise<void>;
+    saveExecution(options: {
+        startedAt: Date;
+        status: 'stale' | 'error' | 'success';
+        errorMessage?: string;
+        result?: PlainObject;
+        job: JobDefinition;
+        jobToRun: JobToRun;
+    }): Promise<void>;
+    afterExecutionSuccess(job: JobDefinition, jobToRun: JobToRun, context: ExecutionContext): Promise<void>;
+    executeJob(jobs: JobsDefinition, jobToRun: JobToRun, respawnWorker: Function): Promise<void>;
+}

package/lib/services/Executor.js

@@ -0,0 +1,195 @@
+"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.Executor = void 0;
+const logger_1 = require("@orion-js/logger");
+const services_1 = require("@orion-js/services");
+const JobsHistoryRepo_1 = require("../repos/JobsHistoryRepo");
+const JobsRepo_1 = require("../repos/JobsRepo");
+const getNextRunDate_1 = require("./getNextRunDate");
+const api_1 = require("@opentelemetry/api");
+let Executor = class Executor {
+    getContext(job, jobToRun, onStale) {
+        let staleTimeout = setTimeout(() => onStale(), jobToRun.lockTime);
+        return {
+            definition: job,
+            record: jobToRun,
+            tries: jobToRun.tries || 0,
+            clearStaleTimeout: () => clearTimeout(staleTimeout),
+            extendLockTime: async (extraTime) => {
+                clearTimeout(staleTimeout);
+                staleTimeout = setTimeout(() => onStale(), extraTime);
+                await this.jobsRepo.extendLockTime(jobToRun.jobId, extraTime);
+            },
+            logger: logger_1.logger.addMetadata({
+                jobName: jobToRun.name,
+                jobId: jobToRun.jobId,
+            }),
+        };
+    }
+    getJobDefinition(jobToRun, jobs) {
+        const job = jobs[jobToRun.name];
+        if (jobToRun.type !== job.type) {
+            logger_1.logger.warn(`Job record "${jobToRun.name}" is "${jobToRun.type}" but definition is "${job.type}"`);
+            return;
+        }
+        return job;
+    }
+    async onError(error, job, jobToRun, context) {
+        const scheduleRecurrent = async () => {
+            if (job.type === 'recurrent') {
+                await this.jobsRepo.scheduleNextRun({
+                    jobId: jobToRun.jobId,
+                    nextRunAt: (0, getNextRunDate_1.getNextRunDate)(job),
+                    addTries: false,
+                    priority: job.priority,
+                });
+            }
+        };
+        if (!job.onError) {
+            context.logger.error(`Error executing job "${jobToRun.name}"`, error);
+            await scheduleRecurrent();
+            return;
+        }
+        context.logger.info(`Error executing job "${jobToRun.name}"`, error);
+        const result = await job.onError(error, jobToRun.params, context);
+        if (result.action === 'dismiss') {
+            await scheduleRecurrent();
+            return;
+        }
+        if (result.action === 'retry') {
+            await this.jobsRepo.scheduleNextRun({
+                jobId: jobToRun.jobId,
+                nextRunAt: (0, getNextRunDate_1.getNextRunDate)(result),
+                addTries: true,
+                priority: job.type === 'recurrent' ? job.priority : jobToRun.priority,
+            });
+        }
+    }
+    async saveExecution(options) {
+        const { startedAt, status, errorMessage, result, job, jobToRun } = options;
+        const endedAt = new Date();
+        if (job.saveExecutionsFor !== 0) {
+            const oneWeek = 1000 * 60 * 60 * 24 * 7;
+            const saveExecutionsFor = job.saveExecutionsFor || oneWeek;
+            await this.jobsHistoryRepo.saveExecution({
+                jobId: jobToRun.jobId,
+                executionId: jobToRun.executionId,
+                jobName: jobToRun.name,
+                type: jobToRun.type,
+                priority: jobToRun.priority,
+                tries: jobToRun.tries,
+                uniqueIdentifier: jobToRun.uniqueIdentifier,
+                startedAt,
+                endedAt,
+                duration: endedAt.getTime() - startedAt.getTime(),
+                expiresAt: new Date(Date.now() + saveExecutionsFor),
+                status,
+                errorMessage,
+                params: jobToRun.params,
+                result,
+            });
+        }
+    }
+    async afterExecutionSuccess(job, jobToRun, context) {
+        if (job.type === 'recurrent') {
+            context.logger.debug(`Scheduling next run for recurrent job "${jobToRun.name}"`);
+            await this.jobsRepo.scheduleNextRun({
+                jobId: jobToRun.jobId,
+                nextRunAt: (0, getNextRunDate_1.getNextRunDate)(job),
+                addTries: false,
+                priority: job.priority,
+            });
+        }
+        if (job.type === 'event') {
+            context.logger.debug(`Removing event job after success "${jobToRun.name}"`);
+            await this.jobsRepo.deleteEventJob(jobToRun.jobId);
+        }
+    }
+    async executeJob(jobs, jobToRun, respawnWorker) {
+        const job = this.getJobDefinition(jobToRun, jobs);
+        if (!job)
+            return;
+        const tracer = api_1.trace.getTracer('orionjs.dogs', '1.0');
+        await tracer.startActiveSpan(`job.${jobToRun.name}.${jobToRun.executionId}`, async (span) => {
+            try {
+                const startedAt = new Date();
+                const onStale = async () => {
+                    if (job.onStale) {
+                        context.logger.info(`Job "${jobToRun.name}" is stale`);
+                        job.onStale(jobToRun.params, context);
+                    }
+                    else {
+                        context.logger.error(`Job "${jobToRun.name}" is stale`);
+                    }
+                    await this.jobsRepo.setJobRecordPriority(jobToRun.jobId, 0);
+                    respawnWorker();
+                    this.saveExecution({
+                        startedAt,
+                        status: 'stale',
+                        result: null,
+                        errorMessage: null,
+                        job,
+                        jobToRun,
+                    });
+                };
+                const context = this.getContext(job, jobToRun, onStale);
+                try {
+                    const result = await job.resolve(jobToRun.params, context);
+                    context.clearStaleTimeout();
+                    this.saveExecution({
+                        startedAt,
+                        status: 'success',
+                        result: result || null,
+                        errorMessage: null,
+                        job,
+                        jobToRun,
+                    });
+                    await this.afterExecutionSuccess(job, jobToRun, context);
+                }
+                catch (error) {
+                    context.clearStaleTimeout();
+                    this.saveExecution({
+                        startedAt,
+                        status: 'error',
+                        result: null,
+                        errorMessage: error.message,
+                        job,
+                        jobToRun,
+                    });
+                    await this.onError(error, job, jobToRun, context);
+                }
+            }
+            catch (error) {
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: error.message,
+                });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+};
+exports.Executor = Executor;
+__decorate([
+    (0, services_1.Inject)(),
+    __metadata("design:type", JobsRepo_1.JobsRepo)
+], Executor.prototype, "jobsRepo", void 0);
+__decorate([
+    (0, services_1.Inject)(),
+    __metadata("design:type", JobsHistoryRepo_1.JobsHistoryRepo)
+], Executor.prototype, "jobsHistoryRepo", void 0);
+exports.Executor = Executor = __decorate([
+    (0, services_1.Service)()
+], Executor);

package/lib/services/WorkerService.d.ts

@@ -0,0 +1,16 @@
+import { JobDefinitionWithName, JobsDefinition } from '../types/JobsDefinition';
+import { StartWorkersConfig } from '../types/StartConfig';
+import { WorkerInstance, WorkersInstance } from '../types/Worker';
+export declare class WorkerService {
+    private jobsRepo;
+    private executor;
+    getJobNames(jobs: JobsDefinition): string[];
+    getJobs(jobs: JobsDefinition): JobDefinitionWithName[];
+    runWorkerLoop(config: StartWorkersConfig, workerInstance: WorkerInstance): Promise<boolean>;
+    startWorker(config: StartWorkersConfig, workerInstance: WorkerInstance): Promise<void>;
+    createWorkersInstanceDefinition(config: StartWorkersConfig): WorkersInstance;
+    ensureRecords(config: StartWorkersConfig): Promise<void>;
+    startANewWorker(config: StartWorkersConfig, workersInstance: WorkersInstance): Promise<void>;
+    runWorkers(config: StartWorkersConfig, workersInstance: WorkersInstance): Promise<void>;
+    startWorkers(userConfig: Partial<StartWorkersConfig>): WorkersInstance;
+}

package/lib/services/WorkerService.js

@@ -0,0 +1,142 @@
+"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.WorkerService = void 0;
+const services_1 = require("@orion-js/services");
+const lodash_1 = require("lodash");
+const JobsRepo_1 = require("../repos/JobsRepo");
+const helpers_1 = require("@orion-js/helpers");
+const Executor_1 = require("./Executor");
+const logger_1 = require("@orion-js/logger");
+let WorkerService = class WorkerService {
+    getJobNames(jobs) {
+        return Object.keys(jobs);
+    }
+    getJobs(jobs) {
+        return Object.keys(jobs).map(name => {
+            return {
+                name,
+                ...jobs[name]
+            };
+        });
+    }
+    async runWorkerLoop(config, workerInstance) {
+        const names = this.getJobNames(config.jobs);
+        logger_1.logger.debug(`Running worker loop [w${workerInstance.workerIndex}] for jobs "${names.join(', ')}"...`);
+        const jobToRun = await this.jobsRepo.getJobAndLock(names, config.lockTime);
+        if (!jobToRun) {
+            logger_1.logger.debug('No job to run');
+            return false;
+        }
+        logger_1.logger.debug(`Got job [w${workerInstance.workerIndex}] to run:`, jobToRun);
+        await this.executor.executeJob(config.jobs, jobToRun, workerInstance.respawn);
+        return true;
+    }
+    async startWorker(config, workerInstance) {
+        while (true) {
+            if (!workerInstance.running) {
+                logger_1.logger.info(`Got signal to stop. Stopping worker [w${workerInstance.workerIndex}]...`);
+                return;
+            }
+            try {
+                const didRun = await this.runWorkerLoop(config, workerInstance);
+                if (!didRun)
+                    await (0, helpers_1.sleep)(config.pollInterval);
+                if (didRun)
+                    await (0, helpers_1.sleep)(config.cooldownPeriod);
+            }
+            catch (error) {
+                logger_1.logger.error(`Error in job runner.`, error);
+                await (0, helpers_1.sleep)(config.pollInterval);
+            }
+        }
+    }
+    createWorkersInstanceDefinition(config) {
+        const workersInstance = {
+            running: true,
+            workersCount: config.workersCount,
+            workers: [],
+            stop: async () => {
+                logger_1.logger.debug('Stopping workers...', workersInstance.workers);
+                workersInstance.running = false;
+                const stopingPromises = workersInstance.workers.map(worker => worker.stop());
+                await Promise.all(stopingPromises);
+            }
+        };
+        return workersInstance;
+    }
+    async ensureRecords(config) {
+        const jobs = this.getJobs(config.jobs);
+        await Promise.all(jobs
+            .filter(job => job.type === 'recurrent')
+            .map(async (job) => {
+            logger_1.logger.debug(`Ensuring records for job "${job.name}"...`);
+            await this.jobsRepo.ensureJobRecord(job);
+        }));
+    }
+    async startANewWorker(config, workersInstance) {
+        const workerIndex = workersInstance.workers.length;
+        logger_1.logger.info(`Starting worker [w${workerIndex}]`);
+        const workerInstance = {
+            running: true,
+            workerIndex,
+            stop: async () => {
+                logger_1.logger.info(`Stopping worker [w${workerIndex}]...`);
+                workerInstance.running = false;
+                await workerInstance.promise;
+            },
+            respawn: async () => {
+                logger_1.logger.info(`Respawning worker [w${workerIndex}]...`);
+                workerInstance.stop();
+                await this.startANewWorker(config, workersInstance);
+            }
+        };
+        const workerPromise = this.startWorker(config, workerInstance);
+        workerInstance.promise = workerPromise;
+        workersInstance.workers.push(workerInstance);
+    }
+    async runWorkers(config, workersInstance) {
+        logger_1.logger.debug('Will ensure records for recurrent jobs');
+        await this.ensureRecords(config);
+        for (const workerIndex of (0, lodash_1.range)(config.workersCount)) {
+            this.startANewWorker(config, workersInstance);
+        }
+    }
+    startWorkers(userConfig) {
+        const defaultConfig = {
+            jobs: {},
+            cooldownPeriod: 100,
+            pollInterval: 3000,
+            workersCount: 4,
+            lockTime: 30 * 1000
+        };
+        const config = {
+            ...defaultConfig,
+            ...userConfig
+        };
+        const workersInstance = this.createWorkersInstanceDefinition(config);
+        logger_1.logger.debug('Starting workers', config);
+        this.runWorkers(config, workersInstance);
+        return workersInstance;
+    }
+};
+exports.WorkerService = WorkerService;
+__decorate([
+    (0, services_1.Inject)(),
+    __metadata("design:type", JobsRepo_1.JobsRepo)
+], WorkerService.prototype, "jobsRepo", void 0);
+__decorate([
+    (0, services_1.Inject)(),
+    __metadata("design:type", Executor_1.Executor)
+], WorkerService.prototype, "executor", void 0);
+exports.WorkerService = WorkerService = __decorate([
+    (0, services_1.Service)()
+], WorkerService);

package/lib/services/WorkerService.test.d.ts

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

package/lib/services/WorkerService.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const services_1 = require("@orion-js/services");
+const WorkerService_1 = require("./WorkerService");
+describe('WorkerService', () => {
+    it('should have a startWorker method', () => {
+        const workerService = (0, services_1.getInstance)(WorkerService_1.WorkerService);
+        expect(workerService.startWorkers).toBeDefined();
+    });
+});

package/lib/services/getNextRunDate.d.ts

@@ -0,0 +1,9 @@
+export type Options = {
+    getNextRun?: () => Date;
+    runIn?: number;
+    runEvery?: number;
+    runAt?: Date;
+} & {
+    [key: string]: any;
+};
+export declare const getNextRunDate: (options: Options) => Date;

package/lib/services/getNextRunDate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextRunDate = void 0;
+const getNextRunDate = (options) => {
+    if (options.runIn) {
+        return new Date(Date.now() + options.runIn);
+    }
+    if (options.runEvery) {
+        return new Date(Date.now() + options.runEvery);
+    }
+    if (options.runAt) {
+        return options.runAt;
+    }
+    if (options.getNextRun) {
+        return options.getNextRun();
+    }
+    return new Date();
+};
+exports.getNextRunDate = getNextRunDate;

package/lib/stale.test.d.ts

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