@kabyeon/nexusjs 0.6.5

package/dist/schedule/index.js

@@ -0,0 +1,1108 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = 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 __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+// src/schedule/cron-parser.ts
+var FIELD_RANGES = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7]
+];
+var FIELD_NAMES = {
+  JAN: 1,
+  FEB: 2,
+  MAR: 3,
+  APR: 4,
+  MAY: 5,
+  JUN: 6,
+  JUL: 7,
+  AUG: 8,
+  SEP: 9,
+  OCT: 10,
+  NOV: 11,
+  DEC: 12,
+  SUN: 0,
+  MON: 1,
+  TUE: 2,
+  WED: 3,
+  THU: 4,
+  FRI: 5,
+  SAT: 6
+};
+var ALIASES = {
+  "@yearly": "0 0 1 1 *",
+  "@annually": "0 0 1 1 *",
+  "@monthly": "0 0 1 * *",
+  "@weekly": "0 0 * * 0",
+  "@daily": "0 0 * * *",
+  "@midnight": "0 0 * * *",
+  "@hourly": "0 * * * *"
+};
+
+class CronField {
+  values;
+  constructor(field, range) {
+    this.values = parseField(field, range);
+  }
+  contains(n) {
+    return this.values.has(n);
+  }
+}
+
+class CronExpression {
+  fields;
+  hasSeconds;
+  constructor(raw) {
+    const expanded = expandAlias(raw);
+    const every = expandEvery(expanded);
+    if (every) {
+      this.hasSeconds = true;
+      this.fields = everyToFields(every);
+      return;
+    }
+    const parts = expanded.trim().split(/\s+/);
+    if (parts.length === 5) {
+      this.hasSeconds = false;
+      this.fields = parts.map((p, i) => new CronField(p, FIELD_RANGES[i]));
+    } else if (parts.length === 6) {
+      this.hasSeconds = true;
+      const sec = [0, 59];
+      this.fields = [
+        new CronField(parts[0], sec),
+        ...parts.slice(1).map((p, i) => new CronField(p, FIELD_RANGES[i]))
+      ];
+    } else {
+      throw new Error(`Invalid cron expression: "${raw}" (expected 5 or 6 fields, got ${parts.length})`);
+    }
+  }
+  next(from, maxYears = 5) {
+    const cap = new Date(from.getTime() + maxYears * 365 * 24 * 60 * 60 * 1000);
+    let cur = new Date(from.getTime() + 1000);
+    cur.setMilliseconds(0);
+    let safety = 0;
+    while (cur <= cap) {
+      if (this.matches(cur)) {
+        return cur;
+      }
+      if (!this.fields[this.hasSeconds ? 4 : 3].contains(cur.getMonth() + 1)) {
+        cur = new Date(cur.getFullYear(), cur.getMonth() + 1, 1, 0, 0, 0, 0);
+        continue;
+      }
+      const domIdx = this.hasSeconds ? 3 : 2;
+      const domField = this.fields[domIdx];
+      if (!domField.contains(cur.getDate())) {
+        const sortedDays = [...domField.values].sort((a, b) => a - b);
+        const nextDay = sortedDays.find((d) => d >= cur.getDate());
+        if (nextDay !== undefined) {
+          cur = new Date(cur.getFullYear(), cur.getMonth(), nextDay, 0, 0, 0, 0);
+        } else {
+          cur = new Date(cur.getFullYear(), cur.getMonth() + 1, sortedDays[0], 0, 0, 0, 0);
+        }
+        continue;
+      }
+      if (!this.fields[this.hasSeconds ? 2 : 1].contains(cur.getHours())) {
+        cur = new Date(cur.getFullYear(), cur.getMonth(), cur.getDate(), cur.getHours() + 1, 0, 0, 0);
+        continue;
+      }
+      if (!this.fields[this.hasSeconds ? 1 : 0].contains(cur.getMinutes())) {
+        cur = new Date(cur.getFullYear(), cur.getMonth(), cur.getDate(), cur.getHours(), cur.getMinutes() + 1, 0, 0);
+        continue;
+      }
+      if (this.hasSeconds && !this.fields[0].contains(cur.getSeconds())) {
+        cur = new Date(cur.getTime() + 1000);
+        continue;
+      }
+      cur = new Date(cur.getTime() + 1000);
+      if (++safety > 1e6)
+        return null;
+    }
+    return null;
+  }
+  matches(d) {
+    const fields = this.hasSeconds ? [
+      d.getSeconds(),
+      d.getMinutes(),
+      d.getHours(),
+      d.getDate(),
+      d.getMonth() + 1,
+      d.getDay()
+    ] : [
+      d.getMinutes(),
+      d.getHours(),
+      d.getDate(),
+      d.getMonth() + 1,
+      d.getDay()
+    ];
+    const domField = this.fields[this.hasSeconds ? 3 : 2];
+    const dowField = this.fields[this.hasSeconds ? 4 : 3];
+    const isWildDom = domField.values.size === FIELD_RANGES[2][1];
+    const isWildDow = dowField.values.size === FIELD_RANGES[4][1] + 1;
+    const dayMatch = isWildDom || isWildDow ? domField.contains(d.getDate()) || dowField.contains(d.getDay()) : domField.contains(d.getDate()) || dowField.contains(d.getDay());
+    for (let i = 0;i < this.fields.length; i++) {
+      if (i === (this.hasSeconds ? 3 : 2))
+        continue;
+      if (!this.fields[i].contains(fields[i]))
+        return false;
+    }
+    return dayMatch;
+  }
+}
+function expandAlias(raw) {
+  const trimmed = raw.trim();
+  const alias = ALIASES[trimmed.toLowerCase()];
+  return alias ?? trimmed;
+}
+function expandEvery(raw) {
+  const m = /^@every\s+(\d+)\s*(s|m|h|d)?$/i.exec(raw.trim());
+  if (!m)
+    return null;
+  const n = Number(m[1]);
+  const unit = (m[2] ?? "s").toLowerCase();
+  switch (unit) {
+    case "s":
+      return n * 1000;
+    case "m":
+      return n * 60 * 1000;
+    case "h":
+      return n * 60 * 60 * 1000;
+    case "d":
+      return n * 24 * 60 * 60 * 1000;
+  }
+  return null;
+}
+function everyToFields(intervalMs) {
+  const seconds = Math.floor(intervalMs / 1000);
+  if (seconds < 60) {
+    if (60 % seconds === 0) {
+      return [
+        new CronField(`*/${seconds}`, [0, 59]),
+        new CronField("*", [0, 59]),
+        new CronField("*", [0, 23]),
+        new CronField("*", [1, 31]),
+        new CronField("*", [1, 12]),
+        new CronField("*", [0, 7])
+      ];
+    }
+  }
+  return [
+    new CronField("0", [0, 59]),
+    new CronField("*", [0, 59]),
+    new CronField("*", [0, 23]),
+    new CronField("*", [1, 31]),
+    new CronField("*", [1, 12]),
+    new CronField("*", [0, 7])
+  ];
+}
+function parseField(field, range) {
+  const out = new Set;
+  const [lo, hi] = range;
+  const parts = field.split(",");
+  for (const partRaw of parts) {
+    const part = partRaw.trim();
+    const stepMatch = /^(.+?)\/(\d+)$/.exec(part);
+    let base = part;
+    let step = 1;
+    if (stepMatch) {
+      base = stepMatch[1];
+      step = Number(stepMatch[2]);
+    }
+    let start;
+    let end;
+    if (base === "*") {
+      start = lo;
+      end = hi;
+    } else if (base.includes("-")) {
+      const [a, b] = base.split("-").map((s) => resolveValue(s, lo, hi));
+      start = a;
+      end = b;
+    } else {
+      const v = resolveValue(base, lo, hi);
+      start = v;
+      end = stepMatch ? hi : v;
+    }
+    if (start > end) {
+      throw new Error(`Invalid range in cron field: "${part}"`);
+    }
+    for (let i = start;i <= end; i += step) {
+      out.add(i);
+    }
+  }
+  return out;
+}
+function resolveValue(token, lo, hi) {
+  const t = token.trim();
+  if (t === "*")
+    return lo;
+  const named = FIELD_NAMES[t.toUpperCase()];
+  if (named !== undefined)
+    return named;
+  const n = Number(t);
+  if (Number.isNaN(n)) {
+    throw new Error(`Invalid cron field value: "${token}"`);
+  }
+  if (n < lo || n > hi) {
+    throw new Error(`Cron value ${n} out of range [${lo}, ${hi}]`);
+  }
+  return n;
+}
+function parseCron(expression) {
+  return new CronExpression(expression);
+}
+function nextCron(expression, from = new Date) {
+  return parseCron(expression).next(from);
+}
+
+// src/schedule/backends/memory.ts
+class MemorySchedulesBackend {
+  #tasks = new Map;
+  #byName = new Map;
+  #listeners = new Set;
+  #tickHandle = null;
+  #tickMs;
+  #maxDriftMs;
+  #defaultTimezone = undefined;
+  #nextId = 1;
+  constructor(options = {}) {
+    this.#tickMs = options.tickMs ?? 1000;
+    this.#maxDriftMs = options.maxDriftMs ?? 60000;
+    this.#defaultTimezone = options.defaultTimezone;
+  }
+  addCron(name, expression, handler, options = {}) {
+    const id = this.#allocateId();
+    const next = nextCron(expression, options.runOnInit ? new Date(Date.now() - 1000) : new Date);
+    const task = {
+      id,
+      name,
+      kind: "cron",
+      expression,
+      nextRunAt: next?.getTime() ?? Date.now() + 60000,
+      invocations: 0,
+      status: "running",
+      handler
+    };
+    this.#tasks.set(id, task);
+    this.#byName.set(name, id);
+    this.#emit({
+      kind: "task:registered",
+      id,
+      name,
+      taskKind: "cron",
+      expression
+    });
+    return id;
+  }
+  addInterval(name, ms, handler) {
+    const id = this.#allocateId();
+    const task = {
+      id,
+      name,
+      kind: "interval",
+      expression: `${ms}ms`,
+      nextRunAt: Date.now() + ms,
+      invocations: 0,
+      status: "running",
+      handler
+    };
+    task.timer = setInterval(() => this.#runTask(id), ms);
+    this.#tasks.set(id, task);
+    this.#byName.set(name, id);
+    this.#emit({
+      kind: "task:registered",
+      id,
+      name,
+      taskKind: "interval",
+      expression: `${ms}ms`
+    });
+    return id;
+  }
+  addTimeout(name, ms, handler) {
+    const id = this.#allocateId();
+    const task = {
+      id,
+      name,
+      kind: "timeout",
+      expression: `${ms}ms`,
+      nextRunAt: Date.now() + ms,
+      invocations: 0,
+      status: "running",
+      handler
+    };
+    task.timer = setTimeout(() => this.#runOnceAndRemove(id), ms);
+    this.#tasks.set(id, task);
+    this.#byName.set(name, id);
+    this.#emit({
+      kind: "task:registered",
+      id,
+      name,
+      taskKind: "timeout",
+      expression: `${ms}ms`
+    });
+    return id;
+  }
+  delete(idOrName) {
+    const id = this.#resolveId(idOrName);
+    if (!id)
+      return false;
+    const task = this.#tasks.get(id);
+    if (!task)
+      return false;
+    this.#clearTimer(task);
+    this.#tasks.delete(id);
+    this.#byName.delete(task.name);
+    this.#emit({ kind: "task:deleted", id });
+    return true;
+  }
+  list() {
+    return [...this.#tasks.values()].map((t) => this.#toPublic(t));
+  }
+  get(idOrName) {
+    const id = this.#resolveId(idOrName);
+    if (!id)
+      return;
+    const task = this.#tasks.get(id);
+    return task ? this.#toPublic(task) : undefined;
+  }
+  pause(idOrName) {
+    const id = this.#resolveId(idOrName);
+    if (!id)
+      return false;
+    const task = this.#tasks.get(id);
+    if (!task)
+      return false;
+    this.#clearTimer(task);
+    task.status = "paused";
+    this.#emit({ kind: "task:paused", id });
+    return true;
+  }
+  resume(idOrName) {
+    const id = this.#resolveId(idOrName);
+    if (!id)
+      return false;
+    const task = this.#tasks.get(id);
+    if (!task)
+      return false;
+    if (task.kind === "interval" && !task.timer) {
+      task.timer = setInterval(() => this.#runTask(id), Number(task.expression.replace("ms", "")));
+    }
+    task.status = "running";
+    this.#emit({ kind: "task:resumed", id });
+    return true;
+  }
+  async stop() {
+    for (const task of this.#tasks.values()) {
+      this.#clearTimer(task);
+    }
+    this.#tasks.clear();
+    this.#byName.clear();
+    if (this.#tickHandle)
+      clearInterval(this.#tickHandle);
+    this.#tickHandle = null;
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  start() {
+    if (this.#tickHandle)
+      return;
+    this.#tickHandle = setInterval(() => this.#tick(), this.#tickMs);
+    const handle = this.#tickHandle;
+    if (typeof handle.unref === "function")
+      handle.unref();
+  }
+  #allocateId() {
+    return `sched-${this.#nextId++}`;
+  }
+  #resolveId(idOrName) {
+    if (this.#tasks.has(idOrName))
+      return idOrName;
+    return this.#byName.get(idOrName) ?? null;
+  }
+  #toPublic(t) {
+    const public_ = {
+      id: t.id,
+      name: t.name,
+      kind: t.kind,
+      expression: t.expression,
+      status: t.status,
+      invocations: t.invocations
+    };
+    if (t.lastRunAt !== undefined) {
+      public_.lastRunAt = new Date(t.lastRunAt).toISOString();
+    }
+    public_.nextRunAt = new Date(t.nextRunAt).toISOString();
+    if (t.lastError !== undefined)
+      public_.lastError = t.lastError;
+    return public_;
+  }
+  #clearTimer(task) {
+    if (task.timer) {
+      clearInterval(task.timer);
+      clearTimeout(task.timer);
+      task.timer = undefined;
+    }
+  }
+  #tick() {
+    const now = Date.now();
+    for (const [id, task] of this.#tasks) {
+      if (task.status !== "running")
+        continue;
+      if (task.kind !== "cron")
+        continue;
+      if (task.nextRunAt > now)
+        continue;
+      this.#runTask(id);
+    }
+  }
+  async#runTask(id) {
+    const task = this.#tasks.get(id);
+    if (!task)
+      return;
+    const startedAt = new Date;
+    this.#emit({
+      kind: "task:invoked",
+      id,
+      name: task.name,
+      startedAt: startedAt.toISOString()
+    });
+    const start = Date.now();
+    try {
+      const result = await task.handler();
+      task.invocations++;
+      task.lastRunAt = start;
+      task.lastError = undefined;
+      this.#emit({
+        kind: "task:completed",
+        id,
+        name: task.name,
+        durationMs: Date.now() - start,
+        returnvalue: result
+      });
+    } catch (err) {
+      task.invocations++;
+      task.lastRunAt = start;
+      const error = err instanceof Error ? err : new Error(String(err));
+      task.lastError = error.message;
+      this.#emit({ kind: "task:failed", id, name: task.name, error });
+    } finally {
+      if (task.kind === "cron" && task.status === "running") {
+        const next = nextCron(task.expression, new Date);
+        if (next) {
+          const drift = next.getTime() - Date.now();
+          task.nextRunAt = drift > this.#maxDriftMs ? Date.now() + 60000 : next.getTime();
+        } else {
+          task.nextRunAt = Date.now() + 60000;
+        }
+      }
+    }
+  }
+  #runOnceAndRemove(id) {
+    this.#runTask(id);
+    const task = this.#tasks.get(id);
+    if (task) {
+      this.#tasks.delete(id);
+      this.#byName.delete(task.name);
+      this.#emit({ kind: "task:deleted", id });
+    }
+  }
+  #emit(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+// src/schedule/backends/cloudflare.ts
+class CloudflareSchedulesBackend {
+  #tasks = new Map;
+  #byName = new Map;
+  #listeners = new Set;
+  #nextId = 1;
+  #validate;
+  constructor(options = {}) {
+    this.#validate = options.validateAgainstTrigger ?? true;
+  }
+  addCron(name, expression, handler, options = {}) {
+    const id = `sched-${this.#nextId++}`;
+    this.#tasks.set(id, { id, name, expression, handler, options });
+    this.#byName.set(name, id);
+    this.#emit({
+      kind: "task:registered",
+      id,
+      name,
+      taskKind: "cron",
+      expression
+    });
+    return id;
+  }
+  addInterval() {
+    throw new Error("[schedule/cloudflare] setInterval is not supported on Workers. " + "Use @Cron with a short interval or use the memory backend for in-process scheduling.");
+  }
+  addTimeout() {
+    throw new Error("[schedule/cloudflare] setTimeout is not supported on Workers. " + 'Use @Cron with a delay (e.g. "@every 30s") or run the work from a request handler.');
+  }
+  delete(idOrName) {
+    const id = this.#resolveId(idOrName);
+    if (!id)
+      return false;
+    const task = this.#tasks.get(id);
+    if (!task)
+      return false;
+    this.#tasks.delete(id);
+    this.#byName.delete(task.name);
+    this.#emit({ kind: "task:deleted", id });
+    return true;
+  }
+  list() {
+    return [...this.#tasks.values()].map((t) => ({
+      id: t.id,
+      name: t.name,
+      kind: "cron",
+      expression: t.expression,
+      status: "running",
+      invocations: 0
+    }));
+  }
+  get(idOrName) {
+    const id = this.#resolveId(idOrName);
+    if (!id)
+      return;
+    const t = this.#tasks.get(id);
+    return t ? {
+      id: t.id,
+      name: t.name,
+      kind: "cron",
+      expression: t.expression,
+      status: "running",
+      invocations: 0
+    } : undefined;
+  }
+  pause() {
+    return false;
+  }
+  resume() {
+    return false;
+  }
+  async stop() {
+    this.#tasks.clear();
+    this.#byName.clear();
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  scheduledHandler() {
+    return async (event) => {
+      for (const task of this.#tasks.values()) {
+        if (this.#validate && task.expression !== event.cron)
+          continue;
+        await this.#dispatch(task, event);
+      }
+    };
+  }
+  async#dispatch(task, event) {
+    const startedAt = new Date;
+    this.#emit({
+      kind: "task:invoked",
+      id: task.id,
+      name: task.name,
+      startedAt: startedAt.toISOString()
+    });
+    try {
+      const result = await task.handler();
+      this.#emit({
+        kind: "task:completed",
+        id: task.id,
+        name: task.name,
+        durationMs: Date.now() - startedAt.getTime(),
+        returnvalue: result
+      });
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.#emit({ kind: "task:failed", id: task.id, name: task.name, error });
+    }
+  }
+  #resolveId(idOrName) {
+    if (this.#tasks.has(idOrName))
+      return idOrName;
+    return this.#byName.get(idOrName) ?? null;
+  }
+  #emit(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/schedule/schedule.service.ts
+class ScheduleService {
+  config;
+  static TOKEN = Symbol.for("nexus:ScheduleService");
+  registry;
+  #listeners = new Set;
+  #started = false;
+  #memoryBackend = null;
+  constructor(config = {}) {
+    this.config = config;
+    this.registry = this.#createBackend(config);
+  }
+  addCron(expression, handler, options = {}) {
+    const name = options.name ?? `cron-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    return this.registry.addCron(name, expression, handler, options);
+  }
+  addInterval(milliseconds, handler, name) {
+    return this.registry.addInterval(name ?? `interval-${Date.now()}`, milliseconds, handler);
+  }
+  addTimeout(milliseconds, handler, name) {
+    return this.registry.addTimeout(name ?? `timeout-${Date.now()}`, milliseconds, handler);
+  }
+  list() {
+    return this.registry.list();
+  }
+  get(idOrName) {
+    return this.registry.get(idOrName);
+  }
+  pause(idOrName) {
+    return this.registry.pause(idOrName);
+  }
+  resume(idOrName) {
+    return this.registry.resume(idOrName);
+  }
+  delete(idOrName) {
+    return this.registry.delete(idOrName);
+  }
+  on(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  start() {
+    if (this.#started)
+      return;
+    this.#started = true;
+    if (this.#memoryBackend) {
+      this.#memoryBackend.start();
+    }
+    this.registry.on((event) => this.#broadcast(event));
+  }
+  async stop() {
+    if (!this.#started)
+      return;
+    this.#started = false;
+    await this.registry.stop();
+  }
+  getMemoryBackend() {
+    return this.#memoryBackend;
+  }
+  getCloudflareBackend() {
+    return this.registry instanceof CloudflareSchedulesBackend ? this.registry : null;
+  }
+  #createBackend(config) {
+    switch (config.backend ?? "memory") {
+      case "memory": {
+        const backend = new MemorySchedulesBackend({
+          tickMs: config.memory?.tickMs ?? 1000,
+          maxDriftMs: config.memory?.maxDriftMs,
+          defaultTimezone: config.defaultTimezone
+        });
+        this.#memoryBackend = backend;
+        return backend;
+      }
+      case "cloudflare":
+        return new CloudflareSchedulesBackend;
+    }
+  }
+  #broadcast(event) {
+    for (const l of this.#listeners) {
+      Promise.resolve(l(event));
+    }
+  }
+}
+ScheduleService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("SCHEDULE_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof ScheduleConfig === "undefined" ? Object : ScheduleConfig
+  ])
+], ScheduleService);
+// src/schedule/schedule.module.ts
+import"reflect-metadata";
+class ScheduleModule {
+  static forRoot(config = {}) {
+    class ConfiguredScheduleModule {
+    }
+    ConfiguredScheduleModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          ScheduleService,
+          { provide: ScheduleService.TOKEN, useExisting: ScheduleService },
+          { provide: "SCHEDULE_CONFIG", useValue: config }
+        ],
+        exports: [ScheduleService, ScheduleService.TOKEN]
+      })
+    ], ConfiguredScheduleModule);
+    Object.defineProperty(ConfiguredScheduleModule, "name", {
+      value: "ConfiguredScheduleModule"
+    });
+    return ConfiguredScheduleModule;
+  }
+}
+ScheduleModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      ScheduleService,
+      { provide: ScheduleService.TOKEN, useExisting: ScheduleService }
+    ],
+    exports: [ScheduleService, ScheduleService.TOKEN]
+  })
+], ScheduleModule);
+// src/schedule/decorators/cron.ts
+import"reflect-metadata";
+var CRON_META = "nexus:schedule:cron";
+var INTERVAL_META = "nexus:schedule:interval";
+var TIMEOUT_META = "nexus:schedule:timeout";
+function Cron(expression, options = {}) {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("@Cron can only decorate methods.");
+    }
+    const ctor = target.constructor;
+    const hooks = Reflect.getMetadata(CRON_META, ctor) ?? [];
+    hooks.push({ method: String(propertyKey), expression, options });
+    Reflect.defineMetadata(CRON_META, hooks, ctor);
+  };
+}
+function Interval(milliseconds, name) {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("@Interval can only decorate methods.");
+    }
+    const ctor = target.constructor;
+    const hooks = Reflect.getMetadata(INTERVAL_META, ctor) ?? [];
+    hooks.push({ method: String(propertyKey), milliseconds, name });
+    Reflect.defineMetadata(INTERVAL_META, hooks, ctor);
+  };
+}
+function Timeout(milliseconds, name) {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("@Timeout can only decorate methods.");
+    }
+    const ctor = target.constructor;
+    const hooks = Reflect.getMetadata(TIMEOUT_META, ctor) ?? [];
+    hooks.push({ method: String(propertyKey), milliseconds, name });
+    Reflect.defineMetadata(TIMEOUT_META, hooks, ctor);
+  };
+}
+function getCronHooks(target) {
+  const ctor = target.constructor ?? target;
+  return Reflect.getMetadata(CRON_META, ctor) ?? [];
+}
+function getIntervalHooks(target) {
+  const ctor = target.constructor ?? target;
+  return Reflect.getMetadata(INTERVAL_META, ctor) ?? [];
+}
+function getTimeoutHooks(target) {
+  const ctor = target.constructor ?? target;
+  return Reflect.getMetadata(TIMEOUT_META, ctor) ?? [];
+}
+async function scanForSchedulers(instance, service) {
+  const ids = [];
+  for (const h of getCronHooks(instance)) {
+    const fn = instance[h.method];
+    if (typeof fn !== "function")
+      continue;
+    const id = service.addCron(h.expression, fn.bind(instance), {
+      ...h.options,
+      name: h.options.name ?? `${instance.constructor.name}.${h.method}`
+    });
+    ids.push(id);
+  }
+  for (const h of getIntervalHooks(instance)) {
+    const fn = instance[h.method];
+    if (typeof fn !== "function")
+      continue;
+    const id = service.addInterval(h.milliseconds, fn.bind(instance), h.name ?? `${instance.constructor.name}.${h.method}`);
+    ids.push(id);
+  }
+  for (const h of getTimeoutHooks(instance)) {
+    const fn = instance[h.method];
+    if (typeof fn !== "function")
+      continue;
+    const id = service.addTimeout(h.milliseconds, fn.bind(instance), h.name ?? `${instance.constructor.name}.${h.method}`);
+    ids.push(id);
+  }
+  return ids;
+}
+export {
+  scanForSchedulers,
+  parseCron,
+  nextCron,
+  getTimeoutHooks,
+  getIntervalHooks,
+  getCronHooks,
+  Timeout,
+  ScheduleService,
+  ScheduleModule,
+  MemorySchedulesBackend,
+  Interval,
+  CronField,
+  CronExpression as CronExpressionClass,
+  CronExpression as CronExpr,
+  Cron,
+  CloudflareSchedulesBackend
+};
+
+//# debugId=D85693F9ABB7EB2064756E2164756E21
+//# sourceMappingURL=index.js.map