@navios/schedule 0.5.0 → 0.7.1

package/lib/index.mjs

@@ -1,228 +1,611 @@
-import { Injectable, inject, Logger, Container } from '@navios/core';
-import { CronJob } from 'cron';
+import { Container, Injectable, Logger, inject } from "@navios/core";
+import { CronJob } from "cron";
 
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __decoratorStart = (base) => [, , , __create(null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
-  return value;
-};
-var __decorateElement = (array, flags, name, decorators, target, extra) => {
-  var it, done, ctx, k = flags & 7, p = false;
-  var j = 0;
-  var extraInitializers = array[j] || (array[j] = []);
-  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
-  __name(target, name);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
-    it = (0, decorators[i])(target, ctx), done._ = 1;
-    __expectFn(it) && (target = it);
-  }
-  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
-};
-
-// src/metadata/cron.metadata.mts
-var CronMetadataKey = Symbol("CronMetadataKey");
+//#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.");
+	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.");
+	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.");
 }
 
-// src/metadata/schedule.metadata.mts
-var ScheduleMetadataKey = Symbol("ControllerMetadataKey");
+//#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.");
+	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;
+	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) {
-  const metadata = target[ScheduleMetadataKey];
-  return !!metadata;
+	return !!target[ScheduleMetadataKey];
 }
 
-// src/decorators/cron.decorator.mts
-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/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;
+	};
 }
-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 Injectable()(target, context);
-  };
+
+//#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 Injectable()(target, context);
+	};
 }
 
-// src/cron.constants.mts
-var Schedule = /* @__PURE__ */ ((Schedule2) => {
-  Schedule2["EveryMinute"] = "*/1 * * * *";
-  Schedule2["EveryFiveMinutes"] = "*/5 * * * *";
-  Schedule2["EveryTenMinutes"] = "*/10 * * * *";
-  Schedule2["EveryFifteenMinutes"] = "*/15 * * * *";
-  Schedule2["EveryThirtyMinutes"] = "*/30 * * * *";
-  Schedule2["EveryHour"] = "0 * * * *";
-  Schedule2["EveryTwoHours"] = "0 */2 * * *";
-  Schedule2["EveryThreeHours"] = "0 */3 * * *";
-  Schedule2["EveryFourHours"] = "0 */4 * * *";
-  Schedule2["EverySixHours"] = "0 */6 * * *";
-  Schedule2["EveryTwelveHours"] = "0 */12 * * *";
-  Schedule2["EveryDay"] = "0 0 * * *";
-  Schedule2["EveryWeek"] = "0 0 * * 0";
-  Schedule2["EveryMonth"] = "0 0 1 * *";
-  return Schedule2;
-})(Schedule || {});
-var _SchedulerService_decorators, _init;
-_SchedulerService_decorators = [Injectable()];
-var _SchedulerService = class _SchedulerService {
-  logger = inject(Logger, {
-    context: _SchedulerService.name
-  });
-  container = inject(Container);
-  jobs = /* @__PURE__ */ new Map();
-  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);
-  }
-  getJob(service, method) {
-    const metadata = extractScheduleMetadata(service);
-    const jobName = `${metadata.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 = CronJob.from({
-        cronTime: job.cronTime,
-        name,
-        async onTick() {
-          try {
-            self.logger.debug("Executing job", name);
-            const instance = await self.container.get(service);
-            await instance[job.classMethod]();
-          } catch (error) {
-            self.logger.error("Error executing job", name, error);
-          }
-        },
-        start: !(job.disabled)
-      });
-      this.jobs.set(name, cronJob);
-    }
-  }
-  startAll() {
-    for (const job of this.jobs.values()) {
-      if (job.isActive) {
-        continue;
-      }
-      job.start();
-    }
-  }
-  stopAll() {
-    for (const job of this.jobs.values()) {
-      if (!job.isActive) {
-        continue;
-      }
-      job.stop();
-    }
-  }
+//#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 = Injectable();
+var SchedulerService = class {
+	static {
+		({c: [_SchedulerService, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	logger = inject(Logger, { context: _SchedulerService.name });
+	container = inject(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 = 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();
+	}
 };
-_init = __decoratorStart();
-_SchedulerService = __decorateElement(_init, 0, "SchedulerService", _SchedulerService_decorators, _SchedulerService);
-__runInitializers(_init, 1, _SchedulerService);
-var SchedulerService = _SchedulerService;
 
-export { Cron, CronMetadataKey, Schedulable, Schedule, ScheduleMetadataKey, SchedulerService, extractScheduleMetadata, getAllCronMetadata, getCronMetadata, getScheduleMetadata, hasScheduleMetadata };
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { Cron, CronMetadataKey, Schedulable, Schedule, ScheduleMetadataKey, _SchedulerService as SchedulerService, extractScheduleMetadata, getAllCronMetadata, getCronMetadata, getScheduleMetadata, hasScheduleMetadata };
 //# sourceMappingURL=index.mjs.map