@navios/schedule 0.5.0 → 0.7.1

package/lib/index.cjs

@@ -0,0 +1,626 @@
+let _navios_core = require("@navios/core");
+let cron = require("cron");
+
+//#region src/metadata/cron.metadata.mts
+const CronMetadataKey = Symbol("CronMetadataKey");
+function getAllCronMetadata(context) {
+	if (context.metadata) {
+		const metadata = context.metadata[CronMetadataKey];
+		if (metadata) return metadata;
+		else {
+			context.metadata[CronMetadataKey] = /* @__PURE__ */ new Set();
+			return context.metadata[CronMetadataKey];
+		}
+	}
+	throw new Error("[Navios-Schedule] Wrong environment.");
+}
+function getCronMetadata(target, context) {
+	if (context.metadata) {
+		const metadata = getAllCronMetadata(context);
+		if (metadata) {
+			const endpointMetadata = Array.from(metadata).find((item) => item.classMethod === target.name);
+			if (endpointMetadata) return endpointMetadata;
+			else {
+				const newMetadata = {
+					classMethod: target.name,
+					cronTime: null,
+					disabled: false
+				};
+				metadata.add(newMetadata);
+				return newMetadata;
+			}
+		}
+	}
+	throw new Error("[Navios-Schedule] Wrong environment.");
+}
+
+//#endregion
+//#region src/metadata/schedule.metadata.mts
+const ScheduleMetadataKey = Symbol("ControllerMetadataKey");
+function getScheduleMetadata(target, context) {
+	if (context.metadata) {
+		const metadata = context.metadata[ScheduleMetadataKey];
+		if (metadata) return metadata;
+		else {
+			const jobsMetadata = getAllCronMetadata(context);
+			const newMetadata = {
+				name: target.name,
+				jobs: jobsMetadata
+			};
+			context.metadata[ScheduleMetadataKey] = newMetadata;
+			target[ScheduleMetadataKey] = newMetadata;
+			return newMetadata;
+		}
+	}
+	throw new Error("[Navios-Schedule] Wrong environment.");
+}
+function extractScheduleMetadata(target) {
+	const metadata = target[ScheduleMetadataKey];
+	if (!metadata) throw new Error("[Navios-Schedule] Controller metadata not found. Make sure to use @Controller decorator.");
+	return metadata;
+}
+function hasScheduleMetadata(target) {
+	return !!target[ScheduleMetadataKey];
+}
+
+//#endregion
+//#region src/decorators/cron.decorator.mts
+/**
+* Decorator that marks a method to run on a cron schedule.
+* 
+* The method must be in a class decorated with `@Schedulable()`.
+* The method will be automatically executed according to the provided cron expression.
+* 
+* @param cronTime - Cron expression (5 or 6 fields) or a pre-defined Schedule constant
+* @param options - Optional configuration for the cron job
+* 
+* @example
+* ```typescript
+* @Schedulable()
+* class TaskService {
+*   // Run daily at midnight
+*   @Cron('0 0 * * *')
+*   async dailyTask() {
+*     console.log('Running daily task')
+*   }
+* 
+*   // Use pre-defined schedule
+*   @Cron(Schedule.EveryFiveMinutes)
+*   async frequentTask() {
+*     console.log('Running every 5 minutes')
+*   }
+* 
+*   // Disabled job (won't start automatically)
+*   @Cron('0 2 * * *', { disabled: true })
+*   async maintenanceTask() {
+*     console.log('Maintenance task')
+*   }
+* }
+* ```
+* 
+* @throws {Error} If applied to something other than a method
+* 
+* @public
+*/ function Cron(cronTime, options) {
+	return (target, context) => {
+		if (context.kind !== "method") throw new Error(`Cron can only be applied to methods, not ${context.kind}`);
+		if (context.metadata) {
+			const metadata = getCronMetadata(target, context);
+			metadata.cronTime = cronTime;
+			metadata.disabled = options?.disabled ?? false;
+		}
+		return target;
+	};
+}
+
+//#endregion
+//#region src/decorators/schedulable.decorator.mts
+/**
+* Decorator that marks a class as schedulable and makes it injectable.
+* 
+* Classes decorated with `@Schedulable()` can contain methods decorated with `@Cron()`
+* that will be automatically scheduled and executed. This decorator also applies
+* the `@Injectable()` decorator, making the class available for dependency injection.
+* 
+* @example
+* ```typescript
+* @Schedulable()
+* class TaskService {
+*   @Cron('0 0 * * *')
+*   async dailyTask() {
+*     // This will run daily at midnight
+*   }
+* }
+* 
+* // Register the service
+* schedulerService.register(TaskService)
+* ```
+* 
+* @throws {Error} If applied to something other than a class
+* 
+* @public
+*/ function Schedulable() {
+	return (target, context) => {
+		if (context.kind !== "class") throw new Error(`SchedulableDecorator can only be applied to classes, not ${context.kind}`);
+		if (context.metadata) getScheduleMetadata(target, context);
+		return (0, _navios_core.Injectable)()(target, context);
+	};
+}
+
+//#endregion
+//#region src/cron.constants.mts
+/**
+* Pre-defined cron schedule constants for common scheduling patterns.
+*
+* These constants provide convenient shortcuts for frequently used cron expressions,
+* making it easier to schedule jobs without manually writing cron expressions.
+*
+* @example
+* ```typescript
+* import { Schedule } from '@navios/schedule'
+*
+* @Schedulable()
+* class TaskService {
+*   @Cron(Schedule.EveryMinute)
+*   async everyMinute() {}
+*
+*   @Cron(Schedule.EveryHour)
+*   async hourly() {}
+*
+*   @Cron(Schedule.EveryDay)
+*   async daily() {}
+* }
+* ```
+*
+* @public
+*/ var Schedule = /* @__PURE__ */ function(Schedule$1) {
+	Schedule$1["EveryMinute"] = "*/1 * * * *";
+	Schedule$1["EveryFiveMinutes"] = "*/5 * * * *";
+	Schedule$1["EveryTenMinutes"] = "*/10 * * * *";
+	Schedule$1["EveryFifteenMinutes"] = "*/15 * * * *";
+	Schedule$1["EveryThirtyMinutes"] = "*/30 * * * *";
+	Schedule$1["EveryHour"] = "0 * * * *";
+	Schedule$1["EveryTwoHours"] = "0 */2 * * *";
+	Schedule$1["EveryThreeHours"] = "0 */3 * * *";
+	Schedule$1["EveryFourHours"] = "0 */4 * * *";
+	Schedule$1["EverySixHours"] = "0 */6 * * *";
+	Schedule$1["EveryTwelveHours"] = "0 */12 * * *";
+	Schedule$1["EveryDay"] = "0 0 * * *";
+	Schedule$1["EveryWeek"] = "0 0 * * 0";
+	Schedule$1["EveryMonth"] = "0 0 1 * *";
+	return Schedule$1;
+}({});
+
+//#endregion
+//#region src/scheduler.service.mts
+function applyDecs2203RFactory() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass;
+let _SchedulerService;
+_dec = (0, _navios_core.Injectable)();
+var SchedulerService = class {
+	static {
+		({c: [_SchedulerService, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	logger = (0, _navios_core.inject)(_navios_core.Logger, { context: _SchedulerService.name });
+	container = (0, _navios_core.inject)(_navios_core.Container);
+	jobs = /* @__PURE__ */ new Map();
+	/**
+	* Registers a schedulable service and starts all its cron jobs.
+	* 
+	* The service must be decorated with `@Schedulable()` and contain methods
+	* decorated with `@Cron()` to be registered successfully.
+	* 
+	* @param service - The schedulable service class to register
+	* @throws {Error} If the service is not decorated with `@Schedulable()`
+	* 
+	* @example
+	* ```typescript
+	* @Schedulable()
+	* class TaskService {
+	*   @Cron('0 0 * * *')
+	*   async dailyTask() {
+	*     // Runs daily at midnight
+	*   }
+	* }
+	* 
+	* schedulerService.register(TaskService)
+	* ```
+	* 
+	* @public
+	*/ register(service) {
+		if (!hasScheduleMetadata(service)) throw new Error(`[Navios-Schedule] Service ${service.name} is not schedulable. Make sure to use @Schedulable decorator.`);
+		const metadata = extractScheduleMetadata(service);
+		this.logger.debug("Scheduling service", metadata.name);
+		this.registerJobs(service, metadata);
+	}
+	/**
+	* Retrieves a specific cron job instance for a method in a schedulable service.
+	* 
+	* @param service - The schedulable service class
+	* @param method - The name of the method decorated with `@Cron()`
+	* @returns The CronJob instance if found, undefined otherwise
+	* 
+	* @example
+	* ```typescript
+	* const job = schedulerService.getJob(TaskService, 'dailyTask')
+	* if (job) {
+	*   console.log('Job is active:', job.isActive)
+	*   job.start() // Manually start the job
+	*   job.stop()  // Manually stop the job
+	* }
+	* ```
+	* 
+	* @public
+	*/ getJob(service, method) {
+		const jobName = `${extractScheduleMetadata(service).name}.${method}()`;
+		return this.jobs.get(jobName);
+	}
+	registerJobs(service, metadata) {
+		const jobs = metadata.jobs;
+		for (const job of jobs) {
+			if (!job.cronTime) {
+				this.logger.debug("Skipping job", job.classMethod);
+				continue;
+			}
+			const name = `${metadata.name}.${job.classMethod}()`;
+			const self = this;
+			const cronJob = cron.CronJob.from({
+				cronTime: job.cronTime,
+				name,
+				async onTick() {
+					try {
+						self.logger.debug("Executing job", name);
+						await (await self.container.get(service))[job.classMethod]();
+					} catch (error) {
+						self.logger.error("Error executing job", name, error);
+					}
+				},
+				start: !job.disabled
+			});
+			this.jobs.set(name, cronJob);
+		}
+	}
+	/**
+	* Starts all registered cron jobs that are currently inactive.
+	* 
+	* Only jobs that are not already active will be started. This method
+	* is useful for resuming all jobs after calling `stopAll()`.
+	* 
+	* @example
+	* ```typescript
+	* // Stop all jobs
+	* schedulerService.stopAll()
+	* 
+	* // Later, resume all jobs
+	* schedulerService.startAll()
+	* ```
+	* 
+	* @public
+	*/ startAll() {
+		for (const job of this.jobs.values()) {
+			if (job.isActive) continue;
+			job.start();
+		}
+	}
+	/**
+	* Stops all registered cron jobs that are currently active.
+	* 
+	* Only jobs that are currently active will be stopped. This method
+	* is useful for pausing all scheduled tasks, for example during
+	* application shutdown or maintenance.
+	* 
+	* @example
+	* ```typescript
+	* // Pause all scheduled jobs
+	* schedulerService.stopAll()
+	* 
+	* // Jobs can be resumed later with startAll()
+	* schedulerService.startAll()
+	* ```
+	* 
+	* @public
+	*/ stopAll() {
+		for (const job of this.jobs.values()) {
+			if (!job.isActive) continue;
+			job.stop();
+		}
+	}
+	static {
+		_initClass();
+	}
+};
+
+//#endregion
+exports.Cron = Cron;
+exports.CronMetadataKey = CronMetadataKey;
+exports.Schedulable = Schedulable;
+exports.Schedule = Schedule;
+exports.ScheduleMetadataKey = ScheduleMetadataKey;
+Object.defineProperty(exports, 'SchedulerService', {
+  enumerable: true,
+  get: function () {
+    return _SchedulerService;
+  }
+});
+exports.extractScheduleMetadata = extractScheduleMetadata;
+exports.getAllCronMetadata = getAllCronMetadata;
+exports.getCronMetadata = getCronMetadata;
+exports.getScheduleMetadata = getScheduleMetadata;
+exports.hasScheduleMetadata = hasScheduleMetadata;
+//# sourceMappingURL=index.cjs.map

package/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["newMetadata: CronMetadata","getAllCronMetadata","ScheduleMetadataKey","Symbol","getScheduleMetadata","target","context","metadata","jobsMetadata","newMetadata","name","jobs","Error","extractScheduleMetadata","hasScheduleMetadata","getCronMetadata","Cron","cronTime","options","target","context","kind","Error","metadata","disabled","Injectable","getScheduleMetadata","Schedulable","target","context","kind","Error","metadata","Schedule","Container","inject","Injectable","Logger","CronJob","extractScheduleMetadata","hasScheduleMetadata","SchedulerService","logger","context","name","container","jobs","Map","register","service","Error","metadata","debug","registerJobs","getJob","method","jobName","get","job","cronTime","classMethod","self","defaultDisabled","cronJob","from","onTick","instance","error","start","disabled","set","startAll","values","isActive","stopAll","stop"],"sources":["../src/metadata/cron.metadata.mts","../src/metadata/schedule.metadata.mts","../src/decorators/cron.decorator.mts","../src/decorators/schedulable.decorator.mts","../src/cron.constants.mts","../src/scheduler.service.mts"],"sourcesContent":["import type { CronJobParams } from 'cron'\n\nexport const CronMetadataKey = Symbol('CronMetadataKey')\n\nexport interface CronMetadata {\n  classMethod: string\n  cronTime: CronJobParams['cronTime'] | null\n  disabled: boolean\n}\n\nexport function getAllCronMetadata(\n  context: ClassMethodDecoratorContext | ClassDecoratorContext,\n): Set<CronMetadata> {\n  if (context.metadata) {\n    const metadata = context.metadata[CronMetadataKey] as\n      | Set<CronMetadata>\n      | undefined\n    if (metadata) {\n      return metadata\n    } else {\n      context.metadata[CronMetadataKey] = new Set<CronMetadata>()\n      return context.metadata[CronMetadataKey] as Set<CronMetadata>\n    }\n  }\n  throw new Error('[Navios-Schedule] Wrong environment.')\n}\n\nexport function getCronMetadata(\n  target: Function,\n  context: ClassMethodDecoratorContext,\n): CronMetadata {\n  if (context.metadata) {\n    const metadata = getAllCronMetadata(context)\n    if (metadata) {\n      const endpointMetadata = Array.from(metadata).find(\n        (item) => item.classMethod === target.name,\n      )\n      if (endpointMetadata) {\n        return endpointMetadata\n      } else {\n        const newMetadata: CronMetadata = {\n          classMethod: target.name,\n          cronTime: null,\n          disabled: false,\n        }\n        metadata.add(newMetadata)\n        return newMetadata\n      }\n    }\n  }\n  throw new Error('[Navios-Schedule] Wrong environment.')\n}\n","import type { ClassType } from '@navios/core'\n\nimport type { CronMetadata } from './cron.metadata.mjs'\n\nimport { getAllCronMetadata } from './cron.metadata.mjs'\n\nexport const ScheduleMetadataKey = Symbol('ControllerMetadataKey')\n\nexport interface ScheduleMetadata {\n  name: string\n  jobs: Set<CronMetadata>\n}\n\nexport function getScheduleMetadata(\n  target: ClassType,\n  context: ClassDecoratorContext,\n): ScheduleMetadata {\n  if (context.metadata) {\n    const metadata = context.metadata[ScheduleMetadataKey] as\n      | ScheduleMetadata\n      | undefined\n    if (metadata) {\n      return metadata\n    } else {\n      const jobsMetadata = getAllCronMetadata(context)\n      const newMetadata: ScheduleMetadata = {\n        name: target.name,\n        jobs: jobsMetadata,\n      }\n      context.metadata[ScheduleMetadataKey] = newMetadata\n      // @ts-expect-error We add a custom metadata key to the target\n      target[ScheduleMetadataKey] = newMetadata\n      return newMetadata\n    }\n  }\n  throw new Error('[Navios-Schedule] Wrong environment.')\n}\n\nexport function extractScheduleMetadata(target: ClassType): ScheduleMetadata {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[ScheduleMetadataKey] as ScheduleMetadata | undefined\n  if (!metadata) {\n    throw new Error(\n      '[Navios-Schedule] Controller metadata not found. Make sure to use @Controller decorator.',\n    )\n  }\n  return metadata\n}\n\nexport function hasScheduleMetadata(target: ClassType): boolean {\n  // @ts-expect-error We add a custom metadata key to the target\n  const metadata = target[ScheduleMetadataKey] as ScheduleMetadata | undefined\n\n  return !!metadata\n}\n","import type { CronJobParams } from 'cron'\n\nimport { getCronMetadata } from '../metadata/index.mjs'\n\n/**\n * Options for configuring a cron job.\n * \n * @public\n */\nexport interface CronOptions {\n  /**\n   * Whether the job should be disabled by default.\n   * Disabled jobs won't start automatically but can be manually started later.\n   * \n   * @default false\n   */\n  disabled?: boolean\n}\n\n/**\n * Decorator that marks a method to run on a cron schedule.\n * \n * The method must be in a class decorated with `@Schedulable()`.\n * The method will be automatically executed according to the provided cron expression.\n * \n * @param cronTime - Cron expression (5 or 6 fields) or a pre-defined Schedule constant\n * @param options - Optional configuration for the cron job\n * \n * @example\n * ```typescript\n * @Schedulable()\n * class TaskService {\n *   // Run daily at midnight\n *   @Cron('0 0 * * *')\n *   async dailyTask() {\n *     console.log('Running daily task')\n *   }\n * \n *   // Use pre-defined schedule\n *   @Cron(Schedule.EveryFiveMinutes)\n *   async frequentTask() {\n *     console.log('Running every 5 minutes')\n *   }\n * \n *   // Disabled job (won't start automatically)\n *   @Cron('0 2 * * *', { disabled: true })\n *   async maintenanceTask() {\n *     console.log('Maintenance task')\n *   }\n * }\n * ```\n * \n * @throws {Error} If applied to something other than a method\n * \n * @public\n */\nexport function Cron(\n  cronTime: CronJobParams['cronTime'],\n  options?: CronOptions,\n) {\n  return (\n    target: () => Promise<void>,\n    context: ClassMethodDecoratorContext,\n  ) => {\n    if (context.kind !== 'method') {\n      throw new Error(\n        `Cron can only be applied to methods, not ${context.kind}`,\n      )\n    }\n    if (context.metadata) {\n      const metadata = getCronMetadata(target, context)\n      metadata.cronTime = cronTime\n      metadata.disabled = options?.disabled ?? false\n    }\n    return target\n  }\n}\n","import type { ClassType } from '@navios/core'\n\nimport { Injectable } from '@navios/core'\n\nimport { getScheduleMetadata } from '../metadata/index.mjs'\n\n/**\n * Decorator that marks a class as schedulable and makes it injectable.\n * \n * Classes decorated with `@Schedulable()` can contain methods decorated with `@Cron()`\n * that will be automatically scheduled and executed. This decorator also applies\n * the `@Injectable()` decorator, making the class available for dependency injection.\n * \n * @example\n * ```typescript\n * @Schedulable()\n * class TaskService {\n *   @Cron('0 0 * * *')\n *   async dailyTask() {\n *     // This will run daily at midnight\n *   }\n * }\n * \n * // Register the service\n * schedulerService.register(TaskService)\n * ```\n * \n * @throws {Error} If applied to something other than a class\n * \n * @public\n */\nexport function Schedulable() {\n  return (target: ClassType, context: ClassDecoratorContext) => {\n    if (context.kind !== 'class') {\n      throw new Error(\n        `SchedulableDecorator can only be applied to classes, not ${context.kind}`,\n      )\n    }\n    if (context.metadata) {\n      getScheduleMetadata(target, context)\n    }\n    return Injectable()(target, context)\n  }\n}\n","/**\n * Pre-defined cron schedule constants for common scheduling patterns.\n *\n * These constants provide convenient shortcuts for frequently used cron expressions,\n * making it easier to schedule jobs without manually writing cron expressions.\n *\n * @example\n * ```typescript\n * import { Schedule } from '@navios/schedule'\n *\n * @Schedulable()\n * class TaskService {\n *   @Cron(Schedule.EveryMinute)\n *   async everyMinute() {}\n *\n *   @Cron(Schedule.EveryHour)\n *   async hourly() {}\n *\n *   @Cron(Schedule.EveryDay)\n *   async daily() {}\n * }\n * ```\n *\n * @public\n */\nexport enum Schedule {\n  EveryMinute = '*/1 * * * *',\n  EveryFiveMinutes = '*/5 * * * *',\n  EveryTenMinutes = '*/10 * * * *',\n  EveryFifteenMinutes = '*/15 * * * *',\n  EveryThirtyMinutes = '*/30 * * * *',\n  EveryHour = '0 * * * *',\n  EveryTwoHours = '0 */2 * * *',\n  EveryThreeHours = '0 */3 * * *',\n  EveryFourHours = '0 */4 * * *',\n  EverySixHours = '0 */6 * * *',\n  EveryTwelveHours = '0 */12 * * *',\n  EveryDay = '0 0 * * *',\n  EveryWeek = '0 0 * * 0',\n  EveryMonth = '0 0 1 * *',\n}\n","import type { ClassType } from '@navios/core'\n\nimport { Container, inject, Injectable, Logger } from '@navios/core'\n\nimport { CronJob } from 'cron'\n\nimport type { ScheduleMetadata } from './metadata/index.mjs'\n\nimport {\n  extractScheduleMetadata,\n  hasScheduleMetadata,\n} from './metadata/index.mjs'\n\n/**\n * Service responsible for managing and executing scheduled cron jobs.\n * \n * The SchedulerService registers schedulable services decorated with `@Schedulable()`\n * and automatically starts their cron jobs based on the `@Cron()` decorator configuration.\n * \n * @example\n * ```typescript\n * import { inject, Injectable } from '@navios/core'\n * import { SchedulerService } from '@navios/schedule'\n * \n * @Injectable()\n * class AppModule {\n *   private readonly scheduler = inject(SchedulerService)\n * \n *   async onModuleInit() {\n *     this.scheduler.register(MySchedulableService)\n *   }\n * }\n * ```\n * \n * @public\n */\n@Injectable()\nexport class SchedulerService {\n  private readonly logger = inject(Logger, {\n    context: SchedulerService.name,\n  })\n  private readonly container = inject(Container)\n  private readonly jobs: Map<string, CronJob> = new Map()\n\n  /**\n   * Registers a schedulable service and starts all its cron jobs.\n   * \n   * The service must be decorated with `@Schedulable()` and contain methods\n   * decorated with `@Cron()` to be registered successfully.\n   * \n   * @param service - The schedulable service class to register\n   * @throws {Error} If the service is not decorated with `@Schedulable()`\n   * \n   * @example\n   * ```typescript\n   * @Schedulable()\n   * class TaskService {\n   *   @Cron('0 0 * * *')\n   *   async dailyTask() {\n   *     // Runs daily at midnight\n   *   }\n   * }\n   * \n   * schedulerService.register(TaskService)\n   * ```\n   * \n   * @public\n   */\n  register(service: ClassType) {\n    if (!hasScheduleMetadata(service)) {\n      throw new Error(\n        `[Navios-Schedule] Service ${service.name} is not schedulable. Make sure to use @Schedulable decorator.`,\n      )\n    }\n    const metadata = extractScheduleMetadata(service)\n    this.logger.debug('Scheduling service', metadata.name)\n    this.registerJobs(service, metadata)\n  }\n\n  /**\n   * Retrieves a specific cron job instance for a method in a schedulable service.\n   * \n   * @param service - The schedulable service class\n   * @param method - The name of the method decorated with `@Cron()`\n   * @returns The CronJob instance if found, undefined otherwise\n   * \n   * @example\n   * ```typescript\n   * const job = schedulerService.getJob(TaskService, 'dailyTask')\n   * if (job) {\n   *   console.log('Job is active:', job.isActive)\n   *   job.start() // Manually start the job\n   *   job.stop()  // Manually stop the job\n   * }\n   * ```\n   * \n   * @public\n   */\n  getJob<T extends ClassType>(\n    service: T,\n    method: keyof InstanceType<T>,\n  ): CronJob | undefined {\n    const metadata = extractScheduleMetadata(service)\n    const jobName = `${metadata.name}.${method as string}()`\n    return this.jobs.get(jobName)\n  }\n\n  private registerJobs(service: ClassType, metadata: ScheduleMetadata) {\n    const jobs = metadata.jobs\n    for (const job of jobs) {\n      if (!job.cronTime) {\n        this.logger.debug('Skipping job', job.classMethod)\n        continue\n      }\n      const name = `${metadata.name}.${job.classMethod}()`\n      const self = this\n      const defaultDisabled = false\n      const cronJob = CronJob.from({\n        cronTime: job.cronTime,\n        name,\n        async onTick() {\n          try {\n            self.logger.debug('Executing job', name)\n            const instance = await self.container.get(service)\n            await instance[job.classMethod]()\n          } catch (error) {\n            self.logger.error('Error executing job', name, error)\n          }\n        },\n        start: !(defaultDisabled || job.disabled),\n      })\n      this.jobs.set(name, cronJob)\n    }\n  }\n\n  /**\n   * Starts all registered cron jobs that are currently inactive.\n   * \n   * Only jobs that are not already active will be started. This method\n   * is useful for resuming all jobs after calling `stopAll()`.\n   * \n   * @example\n   * ```typescript\n   * // Stop all jobs\n   * schedulerService.stopAll()\n   * \n   * // Later, resume all jobs\n   * schedulerService.startAll()\n   * ```\n   * \n   * @public\n   */\n  startAll() {\n    for (const job of this.jobs.values()) {\n      if (job.isActive) {\n        continue\n      }\n      job.start()\n    }\n  }\n\n  /**\n   * Stops all registered cron jobs that are currently active.\n   * \n   * Only jobs that are currently active will be stopped. This method\n   * is useful for pausing all scheduled tasks, for example during\n   * application shutdown or maintenance.\n   * \n   * @example\n   * ```typescript\n   * // Pause all scheduled jobs\n   * schedulerService.stopAll()\n   * \n   * // Jobs can be resumed later with startAll()\n   * schedulerService.startAll()\n   * ```\n   * \n   * @public\n   */\n  stopAll() {\n    for (const job of this.jobs.values()) {\n      if (!job.isActive) {\n        continue\n      }\n      job.stop()\n    }\n  }\n}\n"],"mappings":";;;;AAEA,MAAa,kBAAkB,OAAO,kBAAkB;AAQxD,SAAgB,mBACd,SACmB;AACnB,KAAI,QAAQ,UAAU;EACpB,MAAM,WAAW,QAAQ,SAAS;AAGlC,MAAI,SACF,QAAO;OACF;AACL,WAAQ,SAAS,mCAAmB,IAAI,KAAmB;AAC3D,UAAO,QAAQ,SAAS;;;AAG5B,OAAM,IAAI,MAAM,uCAAuC;;AAGzD,SAAgB,gBACd,QACA,SACc;AACd,KAAI,QAAQ,UAAU;EACpB,MAAM,WAAW,mBAAmB,QAAQ;AAC5C,MAAI,UAAU;GACZ,MAAM,mBAAmB,MAAM,KAAK,SAAS,CAAC,MAC3C,SAAS,KAAK,gBAAgB,OAAO,KACvC;AACD,OAAI,iBACF,QAAO;QACF;IACL,MAAMA,cAA4B;KAChC,aAAa,OAAO;KACpB,UAAU;KACV,UAAU;KACX;AACD,aAAS,IAAI,YAAY;AACzB,WAAO;;;;AAIb,OAAM,IAAI,MAAM,uCAAuC;;;;;AC5CzD,MAAaE,sBAAsBC,OAAO,wBAAA;AAO1C,SAAgBC,oBACdC,QACAC,SAA8B;AAE9B,KAAIA,QAAQC,UAAU;EACpB,MAAMA,WAAWD,QAAQC,SAASL;AAGlC,MAAIK,SACF,QAAOA;OACF;GACL,MAAMC,eAAeP,mBAAmBK,QAAAA;GACxC,MAAMG,cAAgC;IACpCC,MAAML,OAAOK;IACbC,MAAMH;IACR;AACAF,WAAQC,SAASL,uBAAuBO;AAExCJ,UAAOH,uBAAuBO;AAC9B,UAAOA;;;AAGX,OAAM,IAAIG,MAAM,uCAAA;;AAGlB,SAAgBC,wBAAwBR,QAAiB;CAEvD,MAAME,WAAWF,OAAOH;AACxB,KAAI,CAACK,SACH,OAAM,IAAIK,MACR,2FAAA;AAGJ,QAAOL;;AAGT,SAAgBO,oBAAoBT,QAAiB;AAInD,QAAO,CAAC,CAFSA,OAAOH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GCK1B,SAAgBc,KACdC,UACAC,SAAqB;AAErB,SACEC,QACAC,YAAAA;AAEA,MAAIA,QAAQC,SAAS,SACnB,OAAM,IAAIC,MACR,4CAA4CF,QAAQC,OAAM;AAG9D,MAAID,QAAQG,UAAU;GACpB,MAAMA,WAAWR,gBAAgBI,QAAQC,QAAAA;AACzCG,YAASN,WAAWA;AACpBM,YAASC,WAAWN,SAASM,YAAY;;AAE3C,SAAOL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GC3CX,SAAgBQ,cAAAA;AACd,SAAQC,QAAmBC,YAAAA;AACzB,MAAIA,QAAQC,SAAS,QACnB,OAAM,IAAIC,MACR,4DAA4DF,QAAQC,OAAM;AAG9E,MAAID,QAAQG,SACVN,qBAAoBE,QAAQC,QAAAA;AAE9B,uCAAOJ,CAAaG,QAAQC,QAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GChBhC,IAAO,WAAKI,yBAAAA,YAAAA;;;;;;;;;;;;;;;QAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCCWXG;AACM,IAAMK,mBAAN,MAAMA;;;;CACMC,kCAAgBL,qBAAQ,EACvCM,SAASF,kBAAiBG,MAC5B,CAAA;CACiBC,qCAAmBX,uBAAAA;CACnBY,uBAA6B,IAAIC,KAAAA;;;;;;;;;;;;;;;;;;;;;;;;IA0BlDC,SAASC,SAAoB;AAC3B,MAAI,CAACT,oBAAoBS,QAAAA,CACvB,OAAM,IAAIC,MACR,6BAA6BD,QAAQL,KAAK,+DAA8D;EAG5G,MAAMO,WAAWZ,wBAAwBU,QAAAA;AACzC,OAAKP,OAAOU,MAAM,sBAAsBD,SAASP,KAAI;AACrD,OAAKS,aAAaJ,SAASE,SAAAA;;;;;;;;;;;;;;;;;;;;IAsB7BG,OACEL,SACAM,QACqB;EAErB,MAAMC,UAAU,GADCjB,wBAAwBU,QAAAA,CACbL,KAAK,GAAGW,OAAiB;AACrD,SAAO,KAAKT,KAAKW,IAAID,QAAAA;;CAGfH,aAAaJ,SAAoBE,UAA4B;EACnE,MAAML,OAAOK,SAASL;AACtB,OAAK,MAAMY,OAAOZ,MAAM;AACtB,OAAI,CAACY,IAAIC,UAAU;AACjB,SAAKjB,OAAOU,MAAM,gBAAgBM,IAAIE,YAAW;AACjD;;GAEF,MAAMhB,OAAO,GAAGO,SAASP,KAAK,GAAGc,IAAIE,YAAY;GACjD,MAAMC,OAAO;GAEb,MAAME,UAAUzB,aAAQ0B,KAAK;IAC3BL,UAAUD,IAAIC;IACdf;IACA,MAAMqB,SAAAA;AACJ,SAAI;AACFJ,WAAKnB,OAAOU,MAAM,iBAAiBR,KAAAA;AAEnC,aADiB,MAAMiB,KAAKhB,UAAUY,IAAIR,QAAAA,EAC3BS,IAAIE,cAAY;cACxBO,OAAO;AACdN,WAAKnB,OAAOyB,MAAM,uBAAuBvB,MAAMuB,MAAAA;;;IAGnDC,OAAO,CAAqBV,IAAIW;IAClC,CAAA;AACA,QAAKvB,KAAKwB,IAAI1B,MAAMmB,QAAAA;;;;;;;;;;;;;;;;;;;IAqBxBQ,WAAW;AACT,OAAK,MAAMb,OAAO,KAAKZ,KAAK0B,QAAM,EAAI;AACpC,OAAId,IAAIe,SACN;AAEFf,OAAIU,OAAK;;;;;;;;;;;;;;;;;;;;IAsBbM,UAAU;AACR,OAAK,MAAMhB,OAAO,KAAKZ,KAAK0B,QAAM,EAAI;AACpC,OAAI,CAACd,IAAIe,SACP;AAEFf,OAAIiB,MAAI"}