@lunora/scheduler 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,8 @@
+export { default as createScheduler } from './packem_shared/createScheduler-Df9JUjQb.mjs';
+export { default as createWorkpool } from './packem_shared/createWorkpool-Ce0kNM2p.mjs';
+export { createCronTrigger } from './packem_shared/createCronTrigger-Dh4VLxD9.mjs';
+export { CRON_SCHEDULE_KINDS, compileCronSchedule, cronJobs } from './packem_shared/CRON_SCHEDULE_KINDS-C2FflEnq.mjs';
+export { createQueueConsumer, createQueueWorkpool, httpDispatcher } from './packem_shared/createQueueConsumer-Cy-Mp-El.mjs';
+export { SchedulerDO } from './packem_shared/SchedulerDO-DeJHI379.mjs';
+export { isWorkflowReference } from './packem_shared/isWorkflowReference-C9mQkMXt.mjs';
+export { assertValidCronExpression, isValidCronExpression } from './packem_shared/assertValidCronExpression-B9m75qU0.mjs';

package/dist/packem_shared/CRON_SCHEDULE_KINDS-C2FflEnq.mjs

@@ -0,0 +1,140 @@
+import { LunoraError } from '@lunora/errors';
+import { isWorkflowReference } from './isWorkflowReference-C9mQkMXt.mjs';
+import { assertValidCronExpression } from './assertValidCronExpression-B9m75qU0.mjs';
+
+const WEEKDAY_INDEX = {
+  friday: 5,
+  monday: 1,
+  saturday: 6,
+  sunday: 0,
+  thursday: 4,
+  tuesday: 2,
+  wednesday: 3
+};
+const field = (value, label, min, max) => {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/scheduler: cronJobs ${label} must be an integer in [${min.toFixed(0)}, ${max.toFixed(0)}], got ${String(value)}`
+    );
+  }
+  return value.toFixed(0);
+};
+const stepField = (value, label, period) => {
+  const rendered = field(value, label, 1, period - 1);
+  if (period % value !== 0) {
+    throw new LunoraError(
+      "INTERNAL",
+      `@lunora/scheduler: ${label} must evenly divide ${period.toFixed(0)} for a fixed "every ${value.toFixed(0)}" interval — cron "*/${value.toFixed(0)}" means "at values divisible by ${value.toFixed(0)}", which wraps unevenly; pick a divisor of ${period.toFixed(0)}`
+    );
+  }
+  return rendered;
+};
+const compileInterval = (schedule) => {
+  const units = ["seconds", "minutes", "hours"].filter((unit2) => schedule[unit2] !== void 0);
+  if (units.length !== 1) {
+    throw new LunoraError("INTERNAL", `@lunora/scheduler: interval schedule must specify exactly one of { seconds, minutes, hours }`);
+  }
+  const unit = units[0];
+  const value = schedule[unit];
+  if (unit === "seconds") {
+    return `*/${stepField(value, "interval.seconds", 60)} * * * * *`;
+  }
+  if (unit === "minutes") {
+    return `*/${stepField(value, "interval.minutes", 60)} * * * *`;
+  }
+  return `0 */${stepField(value, "interval.hours", 24)} * * *`;
+};
+const compileDaily = (schedule) => {
+  const minute = field(schedule.minuteUTC, "daily.minuteUTC", 0, 59);
+  const hour = field(schedule.hourUTC, "daily.hourUTC", 0, 23);
+  return `${minute} ${hour} * * *`;
+};
+const compileWeekly = (schedule) => {
+  const index = WEEKDAY_INDEX[schedule.dayOfWeek];
+  if (index === void 0) {
+    throw new LunoraError("INTERNAL", `@lunora/scheduler: weekly schedule has invalid dayOfWeek "${schedule.dayOfWeek}"`);
+  }
+  const minute = field(schedule.minuteUTC, "weekly.minuteUTC", 0, 59);
+  const hour = field(schedule.hourUTC, "weekly.hourUTC", 0, 23);
+  return `${minute} ${hour} * * ${index.toFixed(0)}`;
+};
+const compileMonthly = (schedule) => {
+  const day = field(schedule.day, "monthly.day", 1, 31);
+  const minute = field(schedule.minuteUTC, "monthly.minuteUTC", 0, 59);
+  const hour = field(schedule.hourUTC, "monthly.hourUTC", 0, 23);
+  return `${minute} ${hour} ${day} * *`;
+};
+const CRON_SCHEDULE_KINDS = /* @__PURE__ */ new Set(["daily", "interval", "monthly", "weekly"]);
+const compileCronSchedule = (kind, schedule) => {
+  switch (kind) {
+    case "daily": {
+      return compileDaily(schedule);
+    }
+    case "interval": {
+      return compileInterval(schedule);
+    }
+    case "monthly": {
+      return compileMonthly(schedule);
+    }
+    case "weekly": {
+      return compileWeekly(schedule);
+    }
+    default: {
+      throw new LunoraError("INTERNAL", `@lunora/scheduler: unknown cron schedule kind "${String(kind)}"`);
+    }
+  }
+};
+const cronJobs = () => {
+  const jobs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const register = (name, cron, target, args) => {
+    if (typeof name !== "string" || name.trim() === "") {
+      throw new LunoraError("INTERNAL", `@lunora/scheduler: cron job name must be a non-empty string`);
+    }
+    if (seen.has(name)) {
+      throw new LunoraError("INTERNAL", `@lunora/scheduler: duplicate cron job name "${name}" — names must be unique within one cronJobs()`);
+    }
+    if (isWorkflowReference(target)) {
+      assertValidCronExpression(cron, `cron expression for job "${name}"`);
+      seen.add(name);
+      jobs.push({ args: args ?? {}, cron, name, workflow: typeof target.name === "string" ? target.name : "" });
+      return;
+    }
+    if (!target || typeof target.__lunoraRef !== "string") {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/scheduler: cron job "${name}" requires a function reference (e.g. internal.email.digest) or a workflow reference`
+      );
+    }
+    assertValidCronExpression(cron, `cron expression for job "${name}"`);
+    seen.add(name);
+    jobs.push({ args: args ?? {}, cron, functionPath: target.__lunoraRef, name });
+  };
+  const builder = {
+    cron(name, cronExpr, function_, args) {
+      register(name, cronExpr, function_, args);
+      return builder;
+    },
+    daily(name, schedule, function_, args) {
+      register(name, compileCronSchedule("daily", schedule), function_, args);
+      return builder;
+    },
+    interval(name, schedule, function_, args) {
+      register(name, compileCronSchedule("interval", schedule), function_, args);
+      return builder;
+    },
+    jobs: () => [...jobs],
+    monthly(name, schedule, function_, args) {
+      register(name, compileCronSchedule("monthly", schedule), function_, args);
+      return builder;
+    },
+    weekly(name, schedule, function_, args) {
+      register(name, compileCronSchedule("weekly", schedule), function_, args);
+      return builder;
+    }
+  };
+  return builder;
+};
+
+export { CRON_SCHEDULE_KINDS, compileCronSchedule, cronJobs };