@orion-js/dogs 3.12.0 → 3.13.1

package/lib/stale.test.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const logger_1 = require("@orion-js/logger");
+const _1 = require(".");
+(0, logger_1.setLogLevel)('none');
+describe('Stale Jobs Management', () => {
+    it('Should spawn a new worker when a job is stale and kill the stale worker after it ends', async () => {
+        const jobName1 = 'job1' + (0, helpers_1.generateId)();
+        const job1 = (0, _1.defineJob)({
+            type: 'event',
+            async resolve(_, context) {
+                if (context.tries === 1) {
+                    await (0, helpers_1.sleep)(100);
+                }
+                return { status: 'finished' };
+            }
+        });
+        const jobName2 = 'job2' + (0, helpers_1.generateId)();
+        const job2 = (0, _1.defineJob)({
+            type: 'event',
+            async resolve() {
+                return { status: 'finished' };
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobName1]: job1, [jobName2]: job2 },
+            workersCount: 1,
+            pollInterval: 5,
+            cooldownPeriod: 5,
+            lockTime: 10
+        });
+        await (0, _1.scheduleJob)({ name: jobName1 });
+        await (0, _1.scheduleJob)({ name: jobName2 });
+        await (0, helpers_1.sleep)(150);
+        await instance.stop();
+        const executions1 = await _1.jobsHistoryRepo.getExecutions(jobName1);
+        expect(executions1.length).toBe(2);
+        const executions2 = await _1.jobsHistoryRepo.getExecutions(jobName2);
+        expect(executions2.length).toBe(1);
+        expect(instance.workers.length).toBe(2);
+    });
+    it('Should run stale jobs in the lowest priority', async () => {
+        const executions = [];
+        const priotities = [];
+        const jobName1 = 'job1' + (0, helpers_1.generateId)();
+        const job1 = (0, _1.defineJob)({
+            type: 'event',
+            async resolve(_, context) {
+                executions.push('stale');
+                priotities.push(context.record.priority);
+                if (context.tries === 1) {
+                    await (0, helpers_1.sleep)(100);
+                }
+            }
+        });
+        const jobName2 = 'job2' + (0, helpers_1.generateId)();
+        const job2 = (0, _1.defineJob)({
+            type: 'event',
+            async resolve() {
+                executions.push('success');
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobName1]: job1, [jobName2]: job2 },
+            workersCount: 1,
+            pollInterval: 5,
+            cooldownPeriod: 5,
+            lockTime: 10
+        });
+        await (0, _1.scheduleJob)({ name: jobName1 });
+        await (0, _1.scheduleJob)({ name: jobName2 });
+        await (0, helpers_1.sleep)(150);
+        await instance.stop();
+        expect(priotities).toEqual([100, 0]);
+        expect(executions).toEqual(['stale', 'success', 'stale']);
+    });
+    it('Should revert to original priority when execution was stale on recurrent jobs', async () => {
+        const priotities = [];
+        let didStale = false;
+        const jobName = 'job' + (0, helpers_1.generateId)();
+        const job = (0, _1.defineJob)({
+            type: 'recurrent',
+            runEvery: 5,
+            async resolve(_, context) {
+                priotities.push(context.record.priority);
+                if (!didStale) {
+                    didStale = true;
+                    await (0, helpers_1.sleep)(100);
+                }
+            }
+        });
+        const instance = (0, _1.startWorkers)({
+            jobs: { [jobName]: job },
+            workersCount: 1,
+            pollInterval: 5,
+            cooldownPeriod: 5,
+            lockTime: 10
+        });
+        await (0, helpers_1.sleep)(150);
+        await instance.stop();
+        const [first, second, ...others] = priotities;
+        expect(first).toBe(100);
+        expect(second).toBe(0);
+        expect(others.length).toBeGreaterThan(0);
+        expect(others).toEqual(Array(others.length).fill(100));
+    });
+});

package/lib/tests/setup.d.ts

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

package/lib/tests/setup.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongodb_1 = require("@orion-js/mongodb");
+const url = `${global.__MONGO_URI__}jest`;
+process.env.MONGO_URL = url;
+beforeAll(async () => {
+    const connection = (0, mongodb_1.getMongoConnection)({ name: 'main' });
+    await connection.connectionPromise;
+});
+afterAll(async () => {
+    /**
+     * We need to wait on indexes promises to be resolved to close all the handlers
+     */
+    await Promise.all(mongodb_1.createIndexesPromises);
+    for (const connectionName in mongodb_1.connections) {
+        const connection = mongodb_1.connections[connectionName];
+        await connection.client.close();
+    }
+});

package/lib/types/Events.d.ts

@@ -0,0 +1,21 @@
+import { PlainObject } from './HistoryRecord';
+export interface ScheduleJobOptionsBase {
+    name: string;
+    params?: PlainObject;
+    priority?: number;
+    uniqueIdentifier?: string;
+}
+export type ScheduleJobOptionsRunIn = ScheduleJobOptionsBase & {
+    runIn: number;
+};
+export type ScheduleJobOptionsRunAt = ScheduleJobOptionsBase & {
+    runAt: Date;
+};
+export type ScheduleJobOptions = ScheduleJobOptionsRunIn | ScheduleJobOptionsRunAt | ScheduleJobOptionsBase;
+export interface ScheduleJobRecordOptions {
+    name: string;
+    params: PlainObject;
+    nextRunAt: Date;
+    priority: number;
+    uniqueIdentifier?: string;
+}

package/lib/types/Events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/HistoryRecord.d.ts

@@ -0,0 +1,21 @@
+export type PlainObject = {
+    [name: string]: any;
+};
+export declare class HistoryRecord {
+    _id: string;
+    jobId: string;
+    executionId: string;
+    jobName: string;
+    type: 'recurrent' | 'event';
+    priority: number;
+    tries: number;
+    uniqueIdentifier?: string;
+    startedAt: Date;
+    endedAt: Date;
+    duration: number;
+    expiresAt?: Date;
+    status: 'success' | 'error' | 'stale';
+    errorMessage?: string;
+    params?: PlainObject;
+    result?: PlainObject;
+}

package/lib/types/HistoryRecord.js

@@ -0,0 +1,83 @@
+"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.HistoryRecord = void 0;
+const typed_model_1 = require("@orion-js/typed-model");
+let HistoryRecord = class HistoryRecord {
+};
+exports.HistoryRecord = HistoryRecord;
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "_id", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "jobId", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "executionId", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "jobName", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "type", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Number)
+], HistoryRecord.prototype, "priority", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Number)
+], HistoryRecord.prototype, "tries", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "uniqueIdentifier", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Date)
+], HistoryRecord.prototype, "startedAt", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Date)
+], HistoryRecord.prototype, "endedAt", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Number)
+], HistoryRecord.prototype, "duration", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", Date)
+], HistoryRecord.prototype, "expiresAt", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "status", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", String)
+], HistoryRecord.prototype, "errorMessage", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ type: 'blackbox', optional: true }),
+    __metadata("design:type", Object)
+], HistoryRecord.prototype, "params", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ type: 'blackbox', optional: true }),
+    __metadata("design:type", Object)
+], HistoryRecord.prototype, "result", void 0);
+exports.HistoryRecord = HistoryRecord = __decorate([
+    (0, typed_model_1.TypedModel)()
+], HistoryRecord);

package/lib/types/JobRecord.d.ts

@@ -0,0 +1,13 @@
+import { PlainObject } from './HistoryRecord';
+export declare class JobRecord {
+    _id: string;
+    jobName: string;
+    type: 'recurrent' | 'event';
+    priority: number;
+    uniqueIdentifier?: string;
+    nextRunAt: Date;
+    lastRunAt?: Date;
+    lockedUntil?: Date;
+    tries?: number;
+    params?: PlainObject;
+}

package/lib/types/JobRecord.js

@@ -0,0 +1,59 @@
+"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.JobRecord = void 0;
+const typed_model_1 = require("@orion-js/typed-model");
+let JobRecord = class JobRecord {
+};
+exports.JobRecord = JobRecord;
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], JobRecord.prototype, "_id", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], JobRecord.prototype, "jobName", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", String)
+], JobRecord.prototype, "type", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Number)
+], JobRecord.prototype, "priority", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", String)
+], JobRecord.prototype, "uniqueIdentifier", void 0);
+__decorate([
+    (0, typed_model_1.Prop)(),
+    __metadata("design:type", Date)
+], JobRecord.prototype, "nextRunAt", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", Date)
+], JobRecord.prototype, "lastRunAt", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", Date)
+], JobRecord.prototype, "lockedUntil", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ optional: true }),
+    __metadata("design:type", Number)
+], JobRecord.prototype, "tries", void 0);
+__decorate([
+    (0, typed_model_1.Prop)({ type: 'blackbox', optional: true }),
+    __metadata("design:type", Object)
+], JobRecord.prototype, "params", void 0);
+exports.JobRecord = JobRecord = __decorate([
+    (0, typed_model_1.TypedModel)()
+], JobRecord);

package/lib/types/JobsDefinition.d.ts

@@ -0,0 +1,61 @@
+import { PlainObject } from './HistoryRecord';
+import { ExecutionContext } from './Worker';
+export interface JobRetryResultBase {
+    action: 'retry' | 'dismiss';
+}
+export type JobRetryResultRunIn = JobRetryResultBase & {
+    runIn: number;
+};
+export type JobRetryResultRunAt = JobRetryResultBase & {
+    runAt: Date;
+};
+export type JobRetryResult = JobRetryResultRunIn | JobRetryResultRunAt | JobRetryResultBase;
+export interface BaseJobDefinition {
+    /**
+     * The function to execute when the job is executed.
+     */
+    resolve: (params: PlainObject, context: ExecutionContext) => Promise<PlainObject | void>;
+    /**
+     * Called if the job fails.
+     */
+    onError?: (error: Error, params: PlainObject, context: ExecutionContext) => Promise<JobRetryResult>;
+    /**
+     * Called if the job locktime is expired. The job will be executed again.
+     */
+    onStale?: (params: PlainObject, context: ExecutionContext) => Promise<void>;
+    /**
+     * Save the executions of the job time in milliseconds. Default is 1 week. Set to 0 to disable.
+     */
+    saveExecutionsFor?: number;
+}
+export interface RecurrentJobDefinition extends BaseJobDefinition {
+    /**
+     * Type of the job.
+     */
+    type: 'recurrent';
+    /**
+     * A function executed after each execution that returns the date of the next run.
+     */
+    getNextRun?: () => Date;
+    /**
+     * Run every x milliseconds. This will be ignored if getNextRun is defined.
+     */
+    runEvery?: number;
+    /**
+     * The priority of the job. Higher is more priority. Default is 100.
+     */
+    priority?: number;
+}
+export interface EventJobDefinition extends BaseJobDefinition {
+    /**
+     * Type of the job.
+     */
+    type: 'event';
+}
+export type JobDefinition = RecurrentJobDefinition | EventJobDefinition;
+export type JobDefinitionWithName = JobDefinition & {
+    name: string;
+};
+export interface JobsDefinition {
+    [jobName: string]: JobDefinition;
+}

package/lib/types/JobsDefinition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/StartConfig.d.ts

@@ -0,0 +1,28 @@
+import { JobsDefinition } from './JobsDefinition';
+export type LogLevels = 'debug' | 'info' | 'warn' | 'error' | 'none';
+export interface StartWorkersConfig {
+    /**
+     * Object map of the jobs that this workers will execute
+     */
+    jobs: JobsDefinition;
+    /**
+     * Time in milliseconds to wait between each look without results for a job
+     * to run at the database. Default is 3000.
+     */
+    pollInterval: number;
+    /**
+     * Time in milliseconds to wait too look for a job after a job execution. Default is 100.
+     */
+    cooldownPeriod: number;
+    /**
+     * Number of workers to start. Default is 1.
+     */
+    workersCount: number;
+    /**
+     * Time in milliseconds to lock a job for execution. Default is 30000 (30 seconds).
+     * If a job is locked for longer than this time, it will be considered as failed.
+     * This is to prevent a job from being executed multiple times at the same time.
+     * You can extend this time inside a job by calling extendLockTime from context.
+     */
+    lockTime: number;
+}

package/lib/types/StartConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/Worker.d.ts

@@ -0,0 +1,38 @@
+import { OrionLogger } from '@orion-js/logger';
+import { PlainObject } from './HistoryRecord';
+import { JobDefinition } from './JobsDefinition';
+export interface JobToRun {
+    jobId: string;
+    executionId: string;
+    name: string;
+    type: 'event' | 'recurrent';
+    params: PlainObject;
+    tries: number;
+    lockTime: number;
+    priority: number;
+    uniqueIdentifier?: string;
+}
+export interface ExecutionContext {
+    record: JobToRun;
+    definition: JobDefinition;
+    tries: number;
+    logger: OrionLogger;
+    extendLockTime: (extraTime: number) => Promise<void>;
+    clearStaleTimeout: () => void;
+}
+export interface WorkerInstance {
+    running: boolean;
+    workerIndex: number;
+    stop: () => Promise<void>;
+    respawn: () => Promise<void>;
+    promise?: Promise<any>;
+}
+export interface WorkersInstance {
+    running: boolean;
+    workersCount: number;
+    workers: WorkerInstance[];
+    /**
+     * Stop all workers and wait for them to finish
+     */
+    stop: () => Promise<void>;
+}

package/lib/types/Worker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Events';
+export * from './HistoryRecord';
+export * from './JobRecord';
+export * from './JobsDefinition';
+export * from './StartConfig';
+export * from './Worker';

package/lib/types/index.js

@@ -0,0 +1,22 @@
+"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 });
+__exportStar(require("./Events"), exports);
+__exportStar(require("./HistoryRecord"), exports);
+__exportStar(require("./JobRecord"), exports);
+__exportStar(require("./JobsDefinition"), exports);
+__exportStar(require("./StartConfig"), exports);
+__exportStar(require("./Worker"), exports);

package/package.json

@@ -1,45 +1,44 @@
 {
   "name": "@orion-js/dogs",
-  "version": "3.12.0",
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./dist/index.js",
-    "require": "./dist/index.cjs"
-  },
+  "version": "3.13.1",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
-    "dist"
+    "/lib"
   ],
   "author": "nicolaslopezj",
   "license": "MIT",
   "scripts": {
-    "test": "bun test",
-    "build": "bun run build.ts",
-    "dev": "bun --watch src/index.ts",
-    "clean": "rm -rf ./dist"
+    "test": "jest",
+    "prepare": "yarn run build",
+    "clean": "rm -rf ./lib",
+    "build": "yarn run clean && tsc",
+    "watch": "tsc -w",
+    "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@orion-js/helpers": "^4.0.0-alpha.2",
-    "@orion-js/mongodb": "^4.0.0-alpha.2",
-    "@orion-js/services": "^4.0.0-alpha.2",
-    "@orion-js/typed-model": "^4.0.0-alpha.2"
+    "@orion-js/helpers": "^3.13.1",
+    "@orion-js/mongodb": "^3.13.1",
+    "@orion-js/services": "^3.13.1",
+    "@orion-js/typed-model": "^3.13.1"
   },
   "peerDependencies": {
     "@orion-js/logger": "*"
   },
   "devDependencies": {
-    "@types/bun": "^1.2.4",
-    "@orion-js/logger": "^4.0.0-alpha.2",
+    "@orion-js/logger": "^3.13.1",
+    "@shelf/jest-mongodb": "^4.3.2",
+    "@types/jest": "^29.5.12",
     "@types/lodash": "4.14.176",
+    "@types/node": "16.11.7",
+    "jest": "29.7.0",
     "reflect-metadata": "^0.1.13",
+    "ts-jest": "29.1.2",
     "typescript": "^5.4.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2d14bc085d49a33b2a5566bec1caf60c7d0f897e"
-}
+  "gitHead": "18ab5a9711863e6bd3d3c61e7bb8f9067afca82c"
+}