@lunora/scheduler 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/assertValidCronExpression-B9m75qU0.mjs

@@ -0,0 +1,24 @@
+import { LunoraError } from '@lunora/errors';
+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 LunoraError(
+      "INTERNAL",
+      `@lunora/scheduler: invalid ${context} "${schedule}" — expected a standard 5- or 6-field cron expression (e.g. "0 * * * *")`
+    );
+  }
+};
+
+export { assertValidCronExpression, isValidCronExpression };

package/dist/packem_shared/createCronTrigger-Dh4VLxD9.mjs

@@ -0,0 +1,28 @@
+import { LunoraError } from '@lunora/errors';
+import { assertValidCronExpression } from './assertValidCronExpression-B9m75qU0.mjs';
+
+const createCronTrigger = (options) => {
+  if (!options.schedule || !options.fn) {
+    throw new LunoraError("INTERNAL", "@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-Cy-Mp-El.mjs

@@ -0,0 +1,61 @@
+import { LunoraError } from '@lunora/errors';
+
+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 LunoraError("INTERNAL", "@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 LunoraError("INTERNAL", "@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 LunoraError("INTERNAL", `@lunora/scheduler: queue dispatch failed (${response.status.toString()}): ${await response.text()}`);
+    }
+  };
+};
+
+export { createQueueConsumer, createQueueWorkpool, httpDispatcher };

package/dist/packem_shared/createScheduler-Df9JUjQb.mjs

@@ -0,0 +1,52 @@
+import { LunoraError } from '@lunora/errors';
+import { c as callDO, g as getDO } from './do-client-CMJtLoHO.mjs';
+import { isWorkflowReference } from './isWorkflowReference-C9mQkMXt.mjs';
+
+const createScheduler = (options) => {
+  if (!options.namespace) {
+    throw new LunoraError("INTERNAL", "@lunora/scheduler: `namespace` (SchedulerDO binding) is required");
+  }
+  if (!options.originUrl) {
+    throw new LunoraError("INTERNAL", "@lunora/scheduler: `originUrl` is required so the DO can dispatch back to the Worker");
+  }
+  const runAt = async (date, target, args, options_ = {}) => {
+    const scheduledFor = date instanceof Date ? date.getTime() : date;
+    const base = {
+      args,
+      originUrl: options.originUrl,
+      pool: options_.pool,
+      retry: options_.retry,
+      scheduledFor,
+      shardKey: options_.shardKey
+    };
+    if (isWorkflowReference(target)) {
+      if (typeof target.binding !== "string" || target.binding.length === 0) {
+        throw new LunoraError(
+          "INTERNAL",
+          "@lunora/scheduler: workflow/agent schedule target is missing its `binding` — pass the generated `workflows.<name>` / `agents.<name>` reference"
+        );
+      }
+      return callDO(options, "/schedule", { ...base, workflow: target.binding });
+    }
+    const functionPath = typeof target === "string" ? target : target.__lunoraRef;
+    return callDO(options, "/schedule", { ...base, functionPath });
+  };
+  const runAfter = async (delayMs, target, args, options_ = {}) => {
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+      throw new LunoraError("INTERNAL", "@lunora/scheduler: `delayMs` must be a non-negative finite number");
+    }
+    return runAt(Date.now() + delayMs, target, 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-Ce0kNM2p.mjs

@@ -0,0 +1,37 @@
+import { LunoraError } from '@lunora/errors';
+import { g as getDO, c as callDO } from './do-client-CMJtLoHO.mjs';
+
+const createWorkpool = (options) => {
+  if (!options.namespace) {
+    throw new LunoraError("INTERNAL", "@lunora/scheduler: `namespace` (SchedulerDO binding) is required");
+  }
+  if (!options.originUrl) {
+    throw new LunoraError("INTERNAL", "@lunora/scheduler: `originUrl` is required so the DO can dispatch back to the Worker");
+  }
+  if (!Number.isInteger(options.maxConcurrency) || options.maxConcurrency <= 0) {
+    throw new LunoraError("INTERNAL", "@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 LunoraError("INTERNAL", "@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/do-client-CMJtLoHO.mjs

@@ -0,0 +1,42 @@
+import { LunoraError } from '@lunora/errors';
+
+const applyJurisdiction = (namespace, jurisdiction) => {
+  if (jurisdiction === void 0) {
+    return namespace;
+  }
+  if (typeof namespace.jurisdiction !== "function") {
+    throw new TypeError(
+      `@lunora/scheduler: Durable Object namespace does not support jurisdiction("${jurisdiction}") — update @cloudflare/workers-types or remove the jurisdiction option`
+    );
+  }
+  return namespace.jurisdiction(jurisdiction);
+};
+
+const schedulerStub = (options) => {
+  const namespace = applyJurisdiction(options.namespace, options.jurisdiction);
+  return namespace.get(namespace.idFromName(options.instanceName ?? "default"));
+};
+const callDO = async (options, path, body) => {
+  const stub = schedulerStub(options);
+  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 LunoraError("INTERNAL", `@lunora/scheduler: SchedulerDO ${path} failed (${String(response.status)}): ${text}`);
+  }
+  return await response.json();
+};
+const getDO = async (options, path) => {
+  const stub = schedulerStub(options);
+  const response = await stub.fetch(`https://scheduler.internal${path}`, { method: "GET" });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new LunoraError("INTERNAL", `@lunora/scheduler: SchedulerDO ${path} failed (${String(response.status)}): ${text}`);
+  }
+  return await response.json();
+};
+
+export { callDO as c, getDO as g };

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,55 @@
 {
   "name": "@lunora/scheduler",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.10",
   "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": {
+    "@lunora/errors": "1.0.0-alpha.5",
+    "cron-parser": "5.6.1"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }