@orion-js/dogs 3.11.15 → 4.0.0-alpha.3

package/lib/repos/JobsRepo.js

@@ -1,158 +0,0 @@
-"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 helpers_1 = require("@orion-js/helpers");
-const logger_1 = require("@orion-js/logger");
-const mongodb_1 = require("@orion-js/mongodb");
-const services_1 = require("@orion-js/services");
-const lodash_1 = require("lodash");
-const JobRecord_1 = require("../types/JobRecord");
-let JobsRepo = class JobsRepo {
-    constructor() {
-        this.jobs = () => (0, mongodb_1.createCollection)({
-            idGeneration: 'uuid',
-            name: 'orionjs.jobs_dogs_records',
-            model: JobRecord_1.JobRecord,
-            indexes: [
-                {
-                    keys: {
-                        jobName: 1,
-                        priority: -1,
-                        nextRunAt: 1
-                    }
-                },
-                {
-                    keys: {
-                        jobName: 1
-                    },
-                    options: {
-                        unique: true,
-                        partialFilterExpression: { type: 'recurrent' }
-                    }
-                },
-                {
-                    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, lastRunAt: new Date() }
-        }, {
-            mongoOptions: {
-                sort: {
-                    priority: -1,
-                    nextRunAt: 1
-                },
-                returnDocument: 'before'
-            }
-        });
-        if (!job)
-            return;
-        let tries = job.tries || 1;
-        if (job.lockedUntil) {
-            logger_1.logger.info(`Running job "${job.jobName}" that was staled`);
-            this.jobs().updateOne(job._id, { $inc: { tries: 1 } });
-            tries++;
-        }
-        return {
-            jobId: job._id,
-            executionId: (0, helpers_1.generateId)(),
-            name: job.jobName,
-            params: job.params,
-            type: job.type,
-            tries,
-            lockTime,
-            priority: job.priority,
-            uniqueIdentifier: job.uniqueIdentifier
-        };
-    }
-    async setJobRecordPriority(jobId, priority) {
-        await this.jobs().updateOne(jobId, { $set: { priority } });
-    }
-    async scheduleNextRun(options) {
-        const updator = {
-            $set: { nextRunAt: options.nextRunAt, priority: options.priority },
-            $unset: { lockedUntil: '' }
-        };
-        if (options.addTries) {
-            updator.$inc = { tries: 1 };
-        }
-        await this.jobs().updateOne(options.jobId, updator);
-    }
-    async deleteEventJob(jobId) {
-        await this.jobs().deleteOne({ _id: jobId, type: 'event' });
-    }
-    async extendLockTime(jobId, extraTime) {
-        const lockedUntil = new Date(Date.now() + extraTime);
-        await this.jobs().updateOne({
-            _id: jobId
-        }, {
-            $set: { lockedUntil }
-        });
-    }
-    async ensureJobRecord(job) {
-        await this.jobs().connectionPromise;
-        const result = await this.jobs().upsert({
-            jobName: job.name
-        }, {
-            $set: {
-                type: job.type,
-                priority: job.priority
-            },
-            $setOnInsert: {
-                nextRunAt: new Date()
-            }
-        });
-        if (result.upsertedId) {
-            logger_1.logger.debug(`Created job record for "${job.name}"`);
-        }
-        else {
-            logger_1.logger.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,
-                type: 'event'
-            });
-        }
-        catch (error) {
-            if (error.isValidationError &&
-                (0, lodash_1.values)(error.validationErrors).includes('notUnique') &&
-                options.uniqueIdentifier) {
-                logger_1.logger.info(`Job "${options.name}" with identifier "${options.uniqueIdentifier}" already exists`);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-};
-exports.JobsRepo = JobsRepo;
-exports.JobsRepo = JobsRepo = __decorate([
-    (0, services_1.Service)()
-], JobsRepo);

package/lib/service/index.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,50 +0,0 @@
-"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

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

package/lib/service/index.test.js

@@ -1,51 +0,0 @@
-"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

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

package/lib/services/EventsService.js

@@ -1,36 +0,0 @@
-"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

@@ -1,20 +0,0 @@
-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

@@ -1,195 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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;
-}