@twin.org/background-task-scheduler 0.0.2-next.9 → 0.0.3-next.10

package/docs/reference/interfaces/ITaskSchedulerConstructorOptions.md

@@ -4,9 +4,9 @@ Options for the task scheduler constructor.
 
 ## Properties
 
-### loggingComponentType?
+### loggingComponentType? {#loggingcomponenttype}
 
-> `optional` **loggingComponentType**: `string`
+> `optional` **loggingComponentType?**: `string`
 
 The logging component type.
 
@@ -18,8 +18,22 @@ logging
 
 ***
 
-### config?
+### scheduledTaskEntityStorageType? {#scheduledtaskentitystoragetype}
 
-> `optional` **config**: [`ITaskSchedulerConfig`](ITaskSchedulerConfig.md)
+> `optional` **scheduledTaskEntityStorageType?**: `string`
+
+The scheduled task entity storage connector type.
+
+#### Default
+
+```ts
+scheduled-task
+```
+
+***
+
+### config? {#config}
+
+> `optional` **config?**: [`ITaskSchedulerConfig`](ITaskSchedulerConfig.md)
 
 The configuration for the task scheduler.

package/locales/en.json

@@ -10,5 +10,10 @@
 			"taskRemoved": "Task with id \"{id}\" removed",
 			"taskTriggered": "Task with id \"{id}\" triggered at time \"{time}\""
 		}
+	},
+	"warn": {
+		"taskSchedulerService": {
+			"taskStalled": "Task with id \"{id}\" is stalled, last run at \"{lastRunTime}\" and exceeded timeout \"{stalledTaskTimeoutMs}\" ms"
+		}
 	}
 }

package/package.json

@@ -1,10 +1,10 @@
 {
 	"name": "@twin.org/background-task-scheduler",
-	"version": "0.0.2-next.9",
-	"description": "Background task scheduler",
+	"version": "0.0.3-next.10",
+	"description": "Schedules background tasks for one-off or recurring execution windows",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/twinfoundation/background-task.git",
+		"url": "git+https://github.com/iotaledger/twin-background-task.git",
 		"directory": "packages/background-task-scheduler"
 	},
 	"author": "martyn.janes@iota.org",
@@ -14,25 +14,24 @@
 		"node": ">=20.0.0"
 	},
 	"dependencies": {
-		"@twin.org/background-task-models": "0.0.2-next.9",
+		"@twin.org/background-task-models": "0.0.3-next.10",
 		"@twin.org/core": "next",
+		"@twin.org/entity-storage-models": "next",
 		"@twin.org/logging-models": "next",
 		"@twin.org/nameof": "next"
 	},
-	"main": "./dist/cjs/index.cjs",
-	"module": "./dist/esm/index.mjs",
+	"main": "./dist/es/index.js",
 	"types": "./dist/types/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/types/index.d.ts",
-			"require": "./dist/cjs/index.cjs",
-			"import": "./dist/esm/index.mjs"
+			"import": "./dist/es/index.js",
+			"default": "./dist/es/index.js"
 		},
 		"./locales/*.json": "./locales/*.json"
 	},
 	"files": [
-		"dist/cjs",
-		"dist/esm",
+		"dist/es",
 		"dist/types",
 		"locales",
 		"docs"
@@ -50,7 +49,7 @@
 		"async"
 	],
 	"bugs": {
-		"url": "git+https://github.com/twinfoundation/background-task/issues"
+		"url": "git+https://github.com/iotaledger/twin-background-task/issues"
 	},
 	"homepage": "https://twindev.org"
 }

package/dist/cjs/index.cjs

@@ -1,209 +0,0 @@
-'use strict';
-
-var core = require('@twin.org/core');
-
-/**
- * Class for scheduling tasks.
- */
-class TaskSchedulerService {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "TaskSchedulerService";
-    /**
-     * The logger for the task service.
-     * @internal
-     */
-    _logging;
-    /**
-     * The interval in milliseconds at which the tasks are checked.
-     * @internal
-     */
-    _tickInterval;
-    /**
-     * The tasks that are scheduled.
-     * @internal
-     */
-    _tasks;
-    /**
-     * The timer for running scheduled tasks.
-     * @internal
-     */
-    _timer;
-    /**
-     * Create a new instance of TaskSchedulerComponent.
-     * @param options The options for the scheduler.
-     */
-    constructor(options) {
-        this._logging = core.ComponentFactory.getIfExists(options?.loggingComponentType ?? "logging");
-        this._tasks = {};
-        this._tickInterval = options?.config?.overrideInterval ?? 60 * 1000; // Default to 1 minute
-    }
-    /**
-     * The component needs to be stopped when the node is closed.
-     * @param nodeIdentity The identity of the node stopping the component.
-     * @param nodeLoggingComponentType The node logging component type.
-     * @returns Nothing.
-     */
-    async stop(nodeIdentity, nodeLoggingComponentType) {
-        this.stopTimer();
-    }
-    /**
-     * Add a task to the scheduler.
-     * @param taskId The id of the task to add.
-     * @param times The times at which the task should be scheduled.
-     * @param taskCallback The callback to execute when the task is scheduled.
-     * @returns Nothing.
-     */
-    async addTask(taskId, times, taskCallback) {
-        this._tasks[taskId] = {
-            times: times.map(time => ({
-                ...time,
-                nextTriggerTime: core.Is.empty(time.nextTriggerTime)
-                    ? this.calculateNextTriggerTime(time)
-                    : time.nextTriggerTime
-            })),
-            taskCallback
-        };
-        this._logging?.log({
-            level: "info",
-            source: TaskSchedulerService.CLASS_NAME,
-            ts: Date.now(),
-            message: "taskAdded",
-            data: {
-                id: taskId
-            }
-        });
-        await this.startTimer();
-    }
-    /**
-     * Remove a task from the scheduler.
-     * @param taskId The id of the task to remove.
-     * @returns Nothing.
-     */
-    async removeTask(taskId) {
-        if (!core.Is.empty(this._tasks[taskId])) {
-            this._logging?.log({
-                level: "info",
-                source: TaskSchedulerService.CLASS_NAME,
-                ts: Date.now(),
-                message: "taskRemoved",
-                data: {
-                    id: taskId
-                }
-            });
-            delete this._tasks[taskId];
-            if (Object.keys(this._tasks).length === 0) {
-                this.stopTimer();
-            }
-        }
-    }
-    /**
-     * Get the information about the tasks.
-     * @returns The tasks information.
-     */
-    async tasksInfo() {
-        const tasksInfo = {
-            tasks: {}
-        };
-        for (const taskId in this._tasks) {
-            tasksInfo.tasks[taskId] = this._tasks[taskId].times;
-        }
-        return tasksInfo;
-    }
-    /**
-     * Calculate the next run time for a task based on its scheduled times.
-     * @param time The times at which the task should be scheduled.
-     * @returns The update time with the next run.
-     * @internal
-     */
-    calculateNextTriggerTime(time) {
-        let nextTriggerTime = time.nextTriggerTime;
-        if (core.Is.empty(nextTriggerTime)) {
-            nextTriggerTime = Date.now();
-        }
-        if (!core.Is.empty(time.intervalDays)) {
-            nextTriggerTime += time.intervalDays * 24 * 60 * 60 * 1000;
-        }
-        if (!core.Is.empty(time.intervalHours)) {
-            nextTriggerTime += time.intervalHours * 60 * 60 * 1000;
-        }
-        if (!core.Is.empty(time.intervalMinutes)) {
-            nextTriggerTime += time.intervalMinutes * 60 * 1000;
-        }
-        return nextTriggerTime;
-    }
-    /**
-     * Start the timer for running scheduled tasks.
-     * @internal
-     */
-    async startTimer() {
-        if (core.Is.empty(this._timer)) {
-            // Trigger immediately to catch up on any missed tasks
-            await this.triggerScheduledTasks();
-            // Set the timer to run at the specified interval
-            this._timer = setInterval(async () => this.triggerScheduledTasks(), this._tickInterval);
-        }
-    }
-    /**
-     * Stop the timer for running scheduled tasks.
-     * @internal
-     */
-    stopTimer() {
-        if (!core.Is.empty(this._timer)) {
-            clearInterval(this._timer);
-            this._timer = undefined;
-        }
-    }
-    /**
-     * Trigger scheduled tasks based on their next run times.
-     * @internal
-     */
-    async triggerScheduledTasks() {
-        const now = Date.now();
-        for (const taskId in this._tasks) {
-            const task = this._tasks[taskId];
-            for (const taskTime of task.times) {
-                if (!core.Is.empty(taskTime.nextTriggerTime) && taskTime.nextTriggerTime <= now) {
-                    this._logging?.log({
-                        level: "info",
-                        source: TaskSchedulerService.CLASS_NAME,
-                        ts: Date.now(),
-                        message: "taskTriggered",
-                        data: {
-                            id: taskId,
-                            time: new Date(taskTime.nextTriggerTime).toISOString()
-                        }
-                    });
-                    try {
-                        await task.taskCallback();
-                    }
-                    catch (error) {
-                        this._logging?.log({
-                            level: "error",
-                            source: TaskSchedulerService.CLASS_NAME,
-                            ts: Date.now(),
-                            message: "taskFailed",
-                            data: {
-                                id: taskId
-                            },
-                            error: core.BaseError.fromError(error)
-                        });
-                    }
-                    // If the intervals are empty, we do not recalculate a next run time
-                    if (core.Is.empty(taskTime.intervalDays) &&
-                        core.Is.empty(taskTime.intervalHours) &&
-                        core.Is.empty(taskTime.intervalMinutes)) {
-                        taskTime.nextTriggerTime = undefined;
-                    }
-                    else {
-                        // Recalculate the next run time based on the current time and the intervals
-                        taskTime.nextTriggerTime = this.calculateNextTriggerTime(taskTime);
-                    }
-                }
-            }
-        }
-    }
-}
-
-exports.TaskSchedulerService = TaskSchedulerService;