@lunora/scheduler 0.0.0 → 1.0.0-alpha.1

package/dist/packem_shared/assertValidCronExpression-BLfrDgmK.mjs

@@ -0,0 +1,20 @@
+import { CronExpressionParser } from 'cron-parser';
+
+const isValidCronExpression = (schedule) => {
+  if (typeof schedule !== "string" || schedule.trim() === "") {
+    return false;
+  }
+  try {
+    CronExpressionParser.parse(schedule.trim());
+    return true;
+  } catch {
+    return false;
+  }
+};
+const assertValidCronExpression = (schedule, context = "cron expression") => {
+  if (!isValidCronExpression(schedule)) {
+    throw new Error(`@lunora/scheduler: invalid ${context} "${schedule}" — expected a standard 5- or 6-field cron expression (e.g. "0 * * * *")`);
+  }
+};
+
+export { assertValidCronExpression, isValidCronExpression };

package/dist/packem_shared/compileCronSchedule-BaLlXJiN.mjs

@@ -0,0 +1,123 @@
+import { isWorkflowReference } from './isWorkflowReference-C9mQkMXt.mjs';
+import { assertValidCronExpression } from './assertValidCronExpression-BLfrDgmK.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 Error(`@lunora/scheduler: cronJobs ${label} must be an integer in [${min.toFixed(0)}, ${max.toFixed(0)}], got ${String(value)}`);
+  }
+  return value.toFixed(0);
+};
+const compileInterval = (schedule) => {
+  const units = ["seconds", "minutes", "hours"].filter((unit2) => schedule[unit2] !== void 0);
+  if (units.length !== 1) {
+    throw new Error(`@lunora/scheduler: interval schedule must specify exactly one of { seconds, minutes, hours }`);
+  }
+  const unit = units[0];
+  const value = schedule[unit];
+  if (unit === "seconds") {
+    return `*/${field(value, "interval.seconds", 1, 59)} * * * * *`;
+  }
+  if (unit === "minutes") {
+    return `*/${field(value, "interval.minutes", 1, 59)} * * * *`;
+  }
+  return `0 */${field(value, "interval.hours", 1, 23)} * * *`;
+};
+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 Error(`@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 Error(`@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 Error(`@lunora/scheduler: cron job name must be a non-empty string`);
+    }
+    if (seen.has(name)) {
+      throw new Error(`@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 Error(`@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 };

package/dist/packem_shared/createCronTrigger-Cq9IBcWQ.mjs

@@ -0,0 +1,27 @@
+import { assertValidCronExpression } from './assertValidCronExpression-BLfrDgmK.mjs';
+
+const createCronTrigger = (options) => {
+  if (!options.schedule || !options.fn) {
+    throw new Error("@lunora/scheduler: createCronTrigger() requires `schedule` and `fn`");
+  }
+  assertValidCronExpression(options.schedule);
+  const snippet = JSON.stringify(
+    {
+      triggers: {
+        crons: [options.schedule]
+      }
+    },
+    void 0,
+    2
+  );
+  return {
+    crons: [options.schedule],
+    dispatcher: {
+      args: options.args ?? {},
+      functionPath: options.fn.__lunoraRef
+    },
+    wranglerJsonc: snippet
+  };
+};
+
+export { createCronTrigger };

package/dist/packem_shared/createQueueConsumer-DWahNPfz.mjs

@@ -0,0 +1,59 @@
+const trimTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+const createQueueWorkpool = (options) => {
+  if (!options.queue) {
+    throw new Error("@lunora/scheduler: `queue` (a Cloudflare Queue binding) is required");
+  }
+  const enqueue = async (function_, args, enqueueOptions = {}) => {
+    const job = { args, functionPath: function_.__lunoraRef, shardKey: enqueueOptions.shardKey };
+    const sendOptions = enqueueOptions.delaySeconds === void 0 ? void 0 : { delaySeconds: enqueueOptions.delaySeconds };
+    await options.queue.send(job, sendOptions);
+  };
+  const enqueueBatch = async (jobs, sendOptions) => {
+    const messages = jobs.map((job) => {
+      return { body: { args: job.args, functionPath: job.ref.__lunoraRef, shardKey: job.shardKey } };
+    });
+    await options.queue.sendBatch(messages, sendOptions);
+  };
+  return { enqueue, enqueueBatch };
+};
+const isQueueJob = (value) => typeof value === "object" && value !== null && typeof value.functionPath === "string";
+const createQueueConsumer = (options) => async (batch) => {
+  await Promise.all(
+    batch.messages.map(async (message) => {
+      try {
+        if (!isQueueJob(message.body)) {
+          throw new Error("@lunora/scheduler: queue message body is not a QueueJob (missing functionPath)");
+        }
+        await options.dispatch(message.body);
+        message.ack();
+      } catch {
+        message.retry();
+      }
+    })
+  );
+};
+const httpDispatcher = (options) => {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("@lunora/scheduler: no fetch implementation available — pass fetchImpl or run on a platform with global fetch");
+  }
+  const url = `${trimTrailingSlashes(options.originUrl)}/_lunora/scheduler/dispatch`;
+  return async (job) => {
+    const response = await fetchImpl(url, {
+      body: JSON.stringify({ args: job.args ?? {}, functionPath: job.functionPath, shardKey: job.shardKey }),
+      headers: { authorization: `Bearer ${options.adminToken}`, "content-type": "application/json" },
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw new Error(`@lunora/scheduler: queue dispatch failed (${response.status.toString()}): ${await response.text()}`);
+    }
+  };
+};
+
+export { createQueueConsumer, createQueueWorkpool, httpDispatcher };

package/dist/packem_shared/createScheduler-KCso4_at.mjs

@@ -0,0 +1,63 @@
+const callDO = async (options, path, body) => {
+  const stub = options.namespace.get(options.namespace.idFromName(options.instanceName ?? "default"));
+  const response = await stub.fetch(`https://scheduler.internal${path}`, {
+    body: JSON.stringify(body),
+    headers: { "content-type": "application/json" },
+    method: "POST"
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`@lunora/scheduler: SchedulerDO ${path} failed (${String(response.status)}): ${text}`);
+  }
+  return await response.json();
+};
+const getDO = async (options, path) => {
+  const stub = options.namespace.get(options.namespace.idFromName(options.instanceName ?? "default"));
+  const response = await stub.fetch(`https://scheduler.internal${path}`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`@lunora/scheduler: SchedulerDO ${path} failed (${String(response.status)}): ${text}`);
+  }
+  return await response.json();
+};
+const createScheduler = (options) => {
+  if (!options.namespace) {
+    throw new Error("@lunora/scheduler: `namespace` (SchedulerDO binding) is required");
+  }
+  if (!options.originUrl) {
+    throw new Error("@lunora/scheduler: `originUrl` is required so the DO can dispatch back to the Worker");
+  }
+  const runAt = async (date, function_, args, options_ = {}) => {
+    const scheduledFor = date instanceof Date ? date.getTime() : date;
+    return callDO(options, "/schedule", {
+      args,
+      functionPath: function_.__lunoraRef,
+      originUrl: options.originUrl,
+      // Optional workpool / retry-policy passthrough. Absent for ordinary
+      // `runAfter`/`runAt` calls, which keeps the wire payload (and the
+      // DO's behaviour) identical to before this feature.
+      pool: options_.pool,
+      retry: options_.retry,
+      scheduledFor,
+      shardKey: options_.shardKey
+    });
+  };
+  const runAfter = async (delayMs, function_, args, options_ = {}) => {
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+      throw new Error("@lunora/scheduler: `delayMs` must be a non-negative finite number");
+    }
+    return runAt(Date.now() + delayMs, function_, args, options_);
+  };
+  const cancel = async (id) => callDO(options, "/cancel", { id });
+  const list = async () => {
+    const body = await getDO(options, "/list");
+    return Array.isArray(body.records) ? body.records : [];
+  };
+  const get = async (id) => {
+    const body = await getDO(options, `/get?id=${encodeURIComponent(id)}`);
+    return body.record ?? null;
+  };
+  return { cancel, get, list, runAfter, runAt };
+};
+
+export { createScheduler as default };

package/dist/packem_shared/createWorkpool-D5cWPQmH.mjs

@@ -0,0 +1,56 @@
+const callDO = async (options, path, body) => {
+  const stub = options.namespace.get(options.namespace.idFromName(options.instanceName ?? "default"));
+  const response = await stub.fetch(`https://scheduler.internal${path}`, {
+    body: JSON.stringify(body),
+    headers: { "content-type": "application/json" },
+    method: "POST"
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`@lunora/scheduler: SchedulerDO ${path} failed (${String(response.status)}): ${text}`);
+  }
+  return await response.json();
+};
+const getDO = async (options, path) => {
+  const stub = options.namespace.get(options.namespace.idFromName(options.instanceName ?? "default"));
+  const response = await stub.fetch(`https://scheduler.internal${path}`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`@lunora/scheduler: SchedulerDO ${path} failed (${String(response.status)}): ${text}`);
+  }
+  return await response.json();
+};
+const createWorkpool = (options) => {
+  if (!options.namespace) {
+    throw new Error("@lunora/scheduler: `namespace` (SchedulerDO binding) is required");
+  }
+  if (!options.originUrl) {
+    throw new Error("@lunora/scheduler: `originUrl` is required so the DO can dispatch back to the Worker");
+  }
+  if (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency <= 0) {
+    throw new Error("@lunora/scheduler: `maxConcurrency` must be a positive integer");
+  }
+  const name = typeof options.name === "string" && options.name.length > 0 ? options.name : "default";
+  const enqueue = async (function_, args, options_ = {}) => {
+    const delayMs = options_.delayMs ?? 0;
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+      throw new Error("@lunora/scheduler: `delayMs` must be a non-negative finite number");
+    }
+    return callDO(options, "/schedule", {
+      args,
+      functionPath: function_.__lunoraRef,
+      instanceName: options.instanceName ?? "default",
+      maxConcurrency: options.maxConcurrency,
+      originUrl: options.originUrl,
+      pool: name,
+      retry: options_.retry,
+      scheduledFor: Date.now() + delayMs,
+      shardKey: options_.shardKey
+    });
+  };
+  const cancel = async (id) => callDO(options, "/cancel", { id });
+  const status = async () => getDO(options, `/pool?name=${encodeURIComponent(name)}`);
+  return { cancel, enqueue, name, status };
+};
+
+export { createWorkpool as default };

package/dist/packem_shared/isWorkflowReference-C9mQkMXt.mjs

@@ -0,0 +1,3 @@
+const isWorkflowReference = (target) => typeof target === "object" && target !== null && target.isLunoraWorkflow === true;
+
+export { isWorkflowReference };

package/package.json

@@ -1,31 +1,54 @@
 {
   "name": "@lunora/scheduler",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.1",
   "description": "Scheduling for Lunora: runAfter / runAt and Cron Triggers via SchedulerDO",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "cloudflare",
+    "cron",
+    "durable-objects",
+    "lunora",
+    "queues",
+    "scheduler",
+    "workers",
+    "workpool"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/scheduler"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "scheduler",
-    "cron",
-    "queues",
-    "workpool"
+  "files": [
+    "dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "cron-parser": "5.5.0"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }