version_final_sans_test

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/background-scheduled-task.d.ts

@@ -0,0 +1,28 @@
+import { ChildProcess } from 'child_process';
+import { ScheduledTask, TaskContext, TaskEvent, TaskOptions } from '../scheduled-task';
+import { EventEmitter } from 'stream';
+import { StateMachine } from '../state-machine';
+declare class TaskEmitter extends EventEmitter {
+}
+declare class BackgroundScheduledTask implements ScheduledTask {
+    emitter: TaskEmitter;
+    id: string;
+    name: string;
+    cronExpression: any;
+    taskPath: any;
+    options?: any;
+    forkProcess?: ChildProcess;
+    stateMachine: StateMachine;
+    constructor(cronExpression: string, taskPath: string, options?: TaskOptions);
+    getNextRun(): Date | null;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): string;
+    destroy(): Promise<void>;
+    execute(): Promise<any>;
+    on(event: TaskEvent, fun: (context: TaskContext) => Promise<void> | void): void;
+    off(event: TaskEvent, fun: (context: TaskContext) => Promise<void> | void): void;
+    once(event: TaskEvent, fun: (context: TaskContext) => Promise<void> | void): void;
+    private createContext;
+}
+export default BackgroundScheduledTask;

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/background-scheduled-task.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const create_id_1 = require("../../create-id");
+const stream_1 = require("stream");
+const state_machine_1 = require("../state-machine");
+const localized_time_1 = require("../../time/localized-time");
+const logger_1 = __importDefault(require("../../logger"));
+const time_matcher_1 = require("../../time/time-matcher");
+const daemonPath = (0, path_1.resolve)(__dirname, 'daemon.js');
+class TaskEmitter extends stream_1.EventEmitter {
+}
+class BackgroundScheduledTask {
+    emitter;
+    id;
+    name;
+    cronExpression;
+    taskPath;
+    options;
+    forkProcess;
+    stateMachine;
+    constructor(cronExpression, taskPath, options) {
+        this.cronExpression = cronExpression;
+        this.taskPath = taskPath;
+        this.options = options;
+        this.id = (0, create_id_1.createID)('task');
+        this.name = options?.name || this.id;
+        this.emitter = new TaskEmitter();
+        this.stateMachine = new state_machine_1.StateMachine('stopped');
+        this.on('task:stopped', () => {
+            this.forkProcess?.kill();
+            this.forkProcess = undefined;
+            this.stateMachine.changeState('stopped');
+        });
+        this.on('task:destroyed', () => {
+            this.forkProcess?.kill();
+            this.forkProcess = undefined;
+            this.stateMachine.changeState('destroyed');
+        });
+    }
+    getNextRun() {
+        if (this.stateMachine.state !== 'stopped') {
+            const timeMatcher = new time_matcher_1.TimeMatcher(this.cronExpression, this.options?.timezone);
+            return timeMatcher.getNextMatch(new Date());
+        }
+        return null;
+    }
+    start() {
+        return new Promise((resolve, reject) => {
+            if (this.forkProcess) {
+                return resolve(undefined);
+            }
+            const timeout = setTimeout(() => {
+                reject(new Error('Start operation timed out'));
+            }, 5000);
+            try {
+                this.forkProcess = (0, child_process_1.fork)(daemonPath);
+                this.forkProcess.on('error', (err) => {
+                    clearTimeout(timeout);
+                    reject(new Error(`Error on daemon: ${err.message}`));
+                });
+                this.forkProcess.on('exit', (code, signal) => {
+                    if (code !== 0 && signal !== 'SIGTERM') {
+                        const erro = new Error(`node-cron daemon exited with code ${code || signal}`);
+                        logger_1.default.error(erro);
+                        clearTimeout(timeout);
+                        reject(erro);
+                    }
+                });
+                this.forkProcess.on('message', (message) => {
+                    if (message.jsonError) {
+                        if (message.context?.execution) {
+                            message.context.execution.error = deserializeError(message.jsonError);
+                            delete message.jsonError;
+                        }
+                    }
+                    if (message.context?.task?.state) {
+                        this.stateMachine.changeState(message.context?.task?.state);
+                    }
+                    if (message.context) {
+                        const execution = message.context?.execution;
+                        delete execution?.hasError;
+                        const context = this.createContext(new Date(message.context.date), execution);
+                        this.emitter.emit(message.event, context);
+                    }
+                });
+                this.once('task:started', () => {
+                    this.stateMachine.changeState('idle');
+                    clearTimeout(timeout);
+                    resolve(undefined);
+                });
+                this.forkProcess.send({
+                    command: 'task:start',
+                    path: this.taskPath,
+                    cron: this.cronExpression,
+                    options: this.options
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    stop() {
+        return new Promise((resolve, reject) => {
+            if (!this.forkProcess) {
+                return resolve(undefined);
+            }
+            const timeoutId = setTimeout(() => {
+                clearTimeout(timeoutId);
+                reject(new Error('Stop operation timed out'));
+            }, 5000);
+            const cleanupAndResolve = () => {
+                clearTimeout(timeoutId);
+                this.off('task:stopped', onStopped);
+                this.forkProcess = undefined;
+                resolve(undefined);
+            };
+            const onStopped = () => {
+                cleanupAndResolve();
+            };
+            this.once('task:stopped', onStopped);
+            this.forkProcess.send({
+                command: 'task:stop'
+            });
+        });
+    }
+    getStatus() {
+        return this.stateMachine.state;
+    }
+    destroy() {
+        return new Promise((resolve, reject) => {
+            if (!this.forkProcess) {
+                return resolve(undefined);
+            }
+            const timeoutId = setTimeout(() => {
+                clearTimeout(timeoutId);
+                reject(new Error('Destroy operation timed out'));
+            }, 5000);
+            const onDestroy = () => {
+                clearTimeout(timeoutId);
+                this.off('task:destroyed', onDestroy);
+                resolve(undefined);
+            };
+            this.once('task:destroyed', onDestroy);
+            this.forkProcess.send({
+                command: 'task:destroy'
+            });
+        });
+    }
+    execute() {
+        return new Promise((resolve, reject) => {
+            if (!this.forkProcess) {
+                return reject(new Error('Cannot execute background task because it hasn\'t been started yet. Please initialize the task using the start() method before attempting to execute it.'));
+            }
+            const timeoutId = setTimeout(() => {
+                cleanupListeners();
+                reject(new Error('Execution timeout exceeded'));
+            }, 5000);
+            const cleanupListeners = () => {
+                clearTimeout(timeoutId);
+                this.off('execution:finished', onFinished);
+                this.off('execution:failed', onFail);
+            };
+            const onFinished = (context) => {
+                cleanupListeners();
+                resolve(context.execution?.result);
+            };
+            const onFail = (context) => {
+                cleanupListeners();
+                reject(context.execution?.error || new Error('Execution failed without specific error'));
+            };
+            this.once('execution:finished', onFinished);
+            this.once('execution:failed', onFail);
+            this.forkProcess.send({
+                command: 'task:execute'
+            });
+        });
+    }
+    on(event, fun) {
+        this.emitter.on(event, fun);
+    }
+    off(event, fun) {
+        this.emitter.off(event, fun);
+    }
+    once(event, fun) {
+        this.emitter.once(event, fun);
+    }
+    createContext(executionDate, execution) {
+        const localTime = new localized_time_1.LocalizedTime(executionDate, this.options?.timezone);
+        const ctx = {
+            date: localTime.toDate(),
+            dateLocalIso: localTime.toISO(),
+            triggeredAt: new Date(),
+            task: this,
+            execution: execution
+        };
+        return ctx;
+    }
+}
+function deserializeError(str) {
+    const data = JSON.parse(str);
+    const Err = globalThis[data.name] || Error;
+    const err = new Err(data.message);
+    if (data.stack) {
+        err.stack = data.stack;
+    }
+    Object.keys(data).forEach(key => {
+        if (!['name', 'message', 'stack'].includes(key)) {
+            err[key] = data[key];
+        }
+    });
+    return err;
+}
+exports.default = BackgroundScheduledTask;
+//# sourceMappingURL=background-scheduled-task.js.map

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/daemon.d.ts

@@ -0,0 +1,3 @@
+import { ScheduledTask } from "../scheduled-task";
+export declare function startDaemon(message: any): Promise<ScheduledTask>;
+export declare function bind(): void;

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/daemon.js

@@ -0,0 +1,142 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDaemon = startDaemon;
+exports.bind = bind;
+const url_1 = require("url");
+const logger_1 = __importDefault(require("../../logger"));
+const inline_scheduled_task_1 = require("../inline-scheduled-task");
+async function startDaemon(message) {
+    let script;
+    try {
+        script = await Promise.resolve(`${message.path}`).then(s => __importStar(require(s)));
+    }
+    catch {
+        script = await Promise.resolve(`${(0, url_1.fileURLToPath)(message.path)}`).then(s => __importStar(require(s)));
+    }
+    const task = new inline_scheduled_task_1.InlineScheduledTask(message.cron, script.task, message.options);
+    task.on('task:started', (context => sendEvent('task:started', context)));
+    task.on('task:stopped', (context => sendEvent('task:stopped', context)));
+    task.on('task:destroyed', (context => sendEvent('task:destroyed', context)));
+    task.on('execution:started', (context => sendEvent('execution:started', context)));
+    task.on('execution:finished', (context => sendEvent('execution:finished', context)));
+    task.on('execution:failed', (context => sendEvent('execution:failed', context)));
+    task.on('execution:missed', (context => sendEvent('execution:missed', context)));
+    task.on('execution:overlap', (context => sendEvent('execution:overlap', context)));
+    task.on('execution:maxReached', (context => sendEvent('execution:maxReached', context)));
+    if (process.send)
+        process.send({ event: 'daemon:started' });
+    task.start();
+    return task;
+}
+function sendEvent(event, context) {
+    const message = { event: event, context: safelySerializeContext(context) };
+    if (context.execution?.error) {
+        message.jsonError = serializeError(context.execution?.error);
+    }
+    if (process.send)
+        process.send(message);
+}
+function serializeError(err) {
+    const plain = {
+        name: err.name,
+        message: err.message,
+        stack: err.stack,
+        ...Object.getOwnPropertyNames(err)
+            .filter(k => !['name', 'message', 'stack'].includes(k))
+            .reduce((acc, k) => {
+            acc[k] = err[k];
+            return acc;
+        }, {})
+    };
+    return JSON.stringify(plain);
+}
+function safelySerializeContext(context) {
+    const safeContext = {
+        date: context.date,
+        dateLocalIso: context.dateLocalIso,
+        triggeredAt: context.triggeredAt
+    };
+    if (context.task) {
+        safeContext.task = {
+            id: context.task.id,
+            name: context.task.name,
+            status: context.task.getStatus()
+        };
+    }
+    if (context.execution) {
+        safeContext.execution = {
+            id: context.execution.id,
+            reason: context.execution.reason,
+            startedAt: context.execution.startedAt,
+            finishedAt: context.execution.finishedAt,
+            hasError: !!context.execution.error,
+            result: context.execution.result
+        };
+    }
+    return safeContext;
+}
+function bind() {
+    let task;
+    process.on('message', async (message) => {
+        switch (message.command) {
+            case 'task:start':
+                task = await startDaemon(message);
+                return task;
+            case 'task:stop':
+                if (task)
+                    task.stop();
+                return task;
+            case 'task:destroy':
+                if (task)
+                    task.destroy();
+                return task;
+            case 'task:execute':
+                try {
+                    if (task)
+                        await task.execute();
+                }
+                catch (error) {
+                    logger_1.default.debug('Daemon task:execute falied:', error);
+                }
+                return task;
+        }
+    });
+}
+bind();
+//# sourceMappingURL=daemon.js.map

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/daemon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.js","sourceRoot":"","sources":["../../../../src/tasks/background-scheduled-task/daemon.ts"],"names":[],"mappings":"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"}

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.js.map

node_modules/node-cron/dist/cjs/tasks/background-scheduled-task/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/tasks/background-scheduled-task/index.ts"],"names":[],"mappings":""}