@farm.js/core 0.1.60 → 0.1.62

package/dist/{chunk-3PX4AIXO.mjs → chunk-DQF3QLOH.mjs}

@@ -28,8 +28,31 @@ function resolveCronConfig(cron) {
       jobs: []
     };
   }
+  if (typeof cron !== "object" || Array.isArray(cron)) {
+    throw new TypeError("`cron` must be a job map, { provider, jobs }, or false.");
+  }
+  let provider;
+  let entries;
+  if ("provider" in cron && (typeof cron.provider !== "object" || cron.provider === null)) {
+    if (cron.provider !== "host" && cron.provider !== "farmjs") {
+      throw new TypeError(
+        `\`cron.provider\` must be "host" (the deploy platform's scheduler) or "farmjs" (Farm.js Infra), received ${JSON.stringify(cron.provider)}.`
+      );
+    }
+    provider = cron.provider;
+    if (Object.keys(cron).some((key) => key !== "provider" && key !== "jobs")) {
+      throw new TypeError("When `cron.provider` is set, place named jobs inside `cron.jobs`.");
+    }
+    const configured = cron.jobs === void 0 ? {} : cron.jobs;
+    if (!configured || typeof configured !== "object" || Array.isArray(configured)) {
+      throw new TypeError("`cron.jobs` must be a map of job names to configurations.");
+    }
+    entries = configured;
+  } else {
+    entries = cron;
+  }
   const jobs = [];
-  for (const [name, job] of Object.entries(cron)) {
+  for (const [name, job] of Object.entries(entries)) {
     if (!job || typeof job !== "object" || Array.isArray(job)) {
       throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
     }
@@ -37,6 +60,7 @@ function resolveCronConfig(cron) {
     jobs.push(normalizeCronJob(name, job));
   }
   return {
+    ...provider ? { provider } : {},
     enabled: jobs.length > 0,
     secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
     jobs
@@ -50,18 +74,21 @@ async function prepareFarmCronForNitro(config) {
   const path = await import("path");
   const manifestPath = path.join(root, distDir, FARM_CRON_MANIFEST);
   const generatedDir = path.join(root, distDir, ".nitro", "farm-cron");
-  if (!cron.enabled) {
-    await Promise.all([
-      fs.rm(manifestPath, { force: true }),
-      fs.rm(generatedDir, { recursive: true, force: true })
-    ]);
+  const provider = cron.provider ?? "host";
+  const manifest = createFarmCronManifest(cron, provider);
+  await fs.mkdir(path.dirname(manifestPath), { recursive: true });
+  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  await fs.rm(generatedDir, { recursive: true, force: true });
+  if (!cron.enabled || provider === "farmjs") {
     return {
-      jobs: [],
+      jobs: cron.enabled ? cron.jobs : [],
       tasks: {},
-      scheduledTasks: {}
+      scheduledTasks: {},
+      manifestPath,
+      provider
     };
   }
-  await fs.rm(generatedDir, { recursive: true, force: true });
   await fs.mkdir(generatedDir, { recursive: true });
   const tasks = {};
   const wrapperNames = resolveCronWrapperFileNames(cron.jobs.map((job) => job.name));
@@ -74,26 +101,26 @@ async function prepareFarmCronForNitro(config) {
       description: job.description || `Farm cron ${job.name}`
     };
   }
-  const manifest = createFarmCronManifest(cron);
-  await fs.mkdir(path.dirname(manifestPath), { recursive: true });
-  await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
   return {
     jobs: cron.jobs,
     tasks,
     scheduledTasks: createCronScheduledTasks(cron.jobs),
-    manifestPath
+    manifestPath,
+    provider: "host"
   };
 }
-function createFarmCronManifest(cron) {
+function createFarmCronManifest(cron, provider = cron.provider ?? "host") {
   return {
     schemaVersion: 1,
+    provider,
     secretEnv: cron.secretEnv,
-    jobs: cron.jobs.map((job) => ({
+    jobs: (cron.enabled ? cron.jobs : []).map((job) => ({
       name: job.name,
       schedule: job.schedule,
       path: job.path,
-      description: job.description || null
+      description: job.description || null,
+      ...job.timeoutMs !== void 0 ? { timeoutMs: job.timeoutMs } : {},
+      ...job.input !== void 0 ? { input: job.input } : {}
     }))
   };
 }
@@ -163,14 +190,161 @@ function isCronRequestAuthorized(request, options = {}) {
   const headerSecret = request.headers.get("x-farm-cron-secret") || "";
   return farmSecretsMatch(bearer, secret) || farmSecretsMatch(headerSecret, secret);
 }
+var inFlightCronRuns = /* @__PURE__ */ new Set();
+function resolveCronRunControls(options) {
+  if (options.timeoutMs !== void 0 && (typeof options.timeoutMs !== "number" || !Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0)) {
+    throw new TypeError(
+      `Farm cron \`timeoutMs\` must be a positive number of milliseconds; received ${JSON.stringify(options.timeoutMs)}. Remove the option or set a positive number.`
+    );
+  }
+  if (options.overlap !== void 0 && options.overlap !== "skip") {
+    throw new TypeError(
+      `Farm cron \`overlap\` only supports "skip"; received ${JSON.stringify(options.overlap)}. Remove the option to allow overlapping runs.`
+    );
+  }
+  return {
+    timeoutMs: options.timeoutMs,
+    // A fresh object is this route's identity, so unnamed routes never skip each other.
+    overlapKey: options.overlap === "skip" ? options.name ?? {} : void 0
+  };
+}
+function cronSkippedResponse() {
+  return Response.json({ skipped: true }, { status: 409 });
+}
+function cronTimeoutResponse(timeoutMs) {
+  return Response.json(
+    {
+      error: `The cron handler did not finish within its \`timeoutMs\` of ${timeoutMs} milliseconds. Raise \`timeoutMs\` or make the handler finish sooner.`
+    },
+    { status: 504 }
+  );
+}
+function isThenable(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function runCronRouteControlled(controls, controller, run, onSkip, onTimeout) {
+  const { overlapKey, timeoutMs } = controls;
+  if (overlapKey !== void 0) {
+    if (inFlightCronRuns.has(overlapKey)) return onSkip();
+    inFlightCronRuns.add(overlapKey);
+  }
+  const release = () => {
+    if (overlapKey !== void 0) inFlightCronRuns.delete(overlapKey);
+  };
+  let outcome;
+  try {
+    outcome = run();
+  } catch (error) {
+    release();
+    throw error;
+  }
+  if (!isThenable(outcome)) {
+    release();
+    return outcome;
+  }
+  const pending = Promise.resolve(outcome);
+  if (timeoutMs === void 0) return pending.finally(release);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      controller?.abort(
+        new Error(
+          `The cron handler did not finish within its \`timeoutMs\` of ${timeoutMs} milliseconds.`
+        )
+      );
+      resolve(onTimeout());
+    }, timeoutMs);
+    pending.then(
+      (value) => {
+        clearTimeout(timer);
+        release();
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        release();
+        reject(error);
+      }
+    );
+  });
+}
+function createFarmCronRequestContext(request, options, signal) {
+  const name = request.headers.get("x-farm-cron-name") || void 0;
+  const scheduledAtHeader = request.headers.get("x-farm-cron-scheduled-at")?.trim() || "";
+  const scheduledAtMs = /^\d+$/.test(scheduledAtHeader) ? Number(scheduledAtHeader) : Number.NaN;
+  const scheduledAt = Number.isSafeInteger(scheduledAtMs) ? new Date(scheduledAtMs) : void 0;
+  return {
+    ...name !== void 0 ? { name } : {},
+    ...scheduledAt !== void 0 ? { scheduledAt } : {},
+    input: options.input,
+    signal
+  };
+}
+var FARM_CRON_SIGNATURE_HEADER = "farmjs-signature";
+var CRON_SIGNATURE_VERSION = "farmjs-cron-v1";
+var CRON_SIGNATURE_WINDOW_SECONDS = 300;
+var CRON_SIGNATURE_PATTERN = /^t=(\d{1,12}),v1=([0-9a-f]{64})$/;
+function toHex(buffer) {
+  let hex = "";
+  for (const byte of new Uint8Array(buffer)) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+async function farmCronSignature(apiKey, t, pathname) {
+  const encoder = new TextEncoder();
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", encoder.encode(apiKey));
+  const key = await globalThis.crypto.subtle.importKey(
+    "raw",
+    encoder.encode(toHex(digest)),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await globalThis.crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(`${CRON_SIGNATURE_VERSION}
+${t}
+GET ${pathname}`)
+  );
+  return toHex(mac);
+}
+async function authorizeCronRequest(request, options = {}, now = Date.now()) {
+  if (isCronRequestAuthorized(request, options)) return true;
+  const header = request.headers.get(FARM_CRON_SIGNATURE_HEADER);
+  if (!header) return false;
+  if (typeof request.method !== "string" || request.method.toUpperCase() !== "GET") return false;
+  if (typeof request.url !== "string") return false;
+  const parsed = CRON_SIGNATURE_PATTERN.exec(header.trim());
+  if (!parsed) return false;
+  const t = Number(parsed[1]);
+  if (Math.abs(now / 1e3 - t) > CRON_SIGNATURE_WINDOW_SECONDS) return false;
+  const apiKey = readFarmEnvironmentValue("FARMJS_API_KEY");
+  if (!apiKey) return false;
+  let pathname;
+  try {
+    const url = new URL(request.url);
+    if (url.search) return false;
+    pathname = url.pathname;
+  } catch {
+    return false;
+  }
+  const expected = await farmCronSignature(apiKey, t, pathname);
+  return farmSecretsMatch(parsed[2], expected);
+}
 function cronRoute(handler, options = {}) {
-  if (isFarmEndpoint(handler)) return guardCronEndpoint(handler, options);
+  const controls = resolveCronRunControls(options);
+  if (isFarmEndpoint(handler)) return guardCronEndpoint(handler, options, controls);
   const route = handler;
-  return (request, ...args) => {
-    if (!isCronRequestAuthorized(request, options)) {
-      return Promise.resolve(unauthorizedCronResponse());
+  return async (request, ...args) => {
+    if (!await authorizeCronRequest(request, options)) {
+      return unauthorizedCronResponse();
     }
-    return route(request, ...args);
+    return runCronRouteControlled(
+      controls,
+      void 0,
+      () => route(request, ...args),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
   };
 }
 function unauthorizedCronResponse() {
@@ -180,32 +354,76 @@ function isFarmEndpoint(value) {
   return typeof value === "function" && typeof value.__handler === "function";
 }
 var FUNCTION_OWN_KEYS = /* @__PURE__ */ new Set(["length", "name", "prototype", "arguments", "caller"]);
-function guardCronEndpoint(endpoint, options) {
-  const allowed = (context) => {
+function guardCronEndpoint(endpoint, options, controls) {
+  const allowed = async (context) => {
     const request = context?.request;
-    return typeof request?.headers?.get === "function" && isCronRequestAuthorized(request, options);
+    if (typeof request?.headers?.get !== "function") return false;
+    return authorizeCronRequest(request, options);
   };
-  const guarded = function(context) {
-    return allowed(context) ? endpoint.call(this, context) : Promise.resolve(unauthorizedCronResponse());
+  const withCron = (context) => {
+    const controller = new AbortController();
+    const cron = createFarmCronRequestContext(
+      context.request,
+      options,
+      controller.signal
+    );
+    const invocation = {
+      ...context,
+      context: { ...context.context, cron }
+    };
+    return { controller, invocation };
+  };
+  const guarded = async function(context) {
+    if (!await allowed(context)) return unauthorizedCronResponse();
+    const { controller, invocation } = withCron(context);
+    return runCronRouteControlled(
+      controls,
+      controller,
+      () => endpoint.call(this, invocation),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
   };
   for (const key of Reflect.ownKeys(endpoint)) {
     if (typeof key === "string" && FUNCTION_OWN_KEYS.has(key)) continue;
     Object.defineProperty(guarded, key, Object.getOwnPropertyDescriptor(endpoint, key));
   }
-  guarded.__handler = (context) => allowed(context) ? endpoint.__handler(context) : unauthorizedCronResponse();
+  guarded.__handler = async (context) => {
+    if (!await allowed(context)) return unauthorizedCronResponse();
+    const { controller, invocation } = withCron(context);
+    return runCronRouteControlled(
+      controls,
+      controller,
+      () => endpoint.__handler(invocation),
+      cronSkippedResponse,
+      () => cronTimeoutResponse(controls.timeoutMs)
+    );
+  };
   const invoke = endpoint.__farmInvoke;
   if (invoke) {
-    guarded.__farmInvoke = (context) => allowed(context) ? invoke(context) : {
-      result: unauthorizedCronResponse(),
-      context: context.context,
-      handlerExecuted: false,
-      invalidations: []
+    guarded.__farmInvoke = async (context) => {
+      const denied = (result) => ({
+        result,
+        context: context.context,
+        handlerExecuted: false,
+        invalidations: []
+      });
+      if (!await allowed(context)) return denied(unauthorizedCronResponse());
+      const { controller, invocation } = withCron(context);
+      return runCronRouteControlled(
+        controls,
+        controller,
+        () => invoke(invocation),
+        () => denied(cronSkippedResponse()),
+        () => denied(cronTimeoutResponse(controls.timeoutMs))
+      );
     };
   }
   return guarded;
 }
+var FARM_CRON_NAME_SEGMENT_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 function normalizeCronJob(name, job) {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+  if (!FARM_CRON_NAME_SEGMENT_PATTERN.test(name)) {
     throw new TypeError(
       `Farm cron name ${JSON.stringify(name)} must start with a letter or number and contain only letters, numbers, dots, underscores, or hyphens.`
     );
@@ -433,5 +651,10 @@ export {
   createFarmCronCloudflareConfig,
   mergeScheduledTasks,
   isCronRequestAuthorized,
-  cronRoute
+  FARM_CRON_SIGNATURE_HEADER,
+  farmCronSignature,
+  authorizeCronRequest,
+  cronRoute,
+  FARM_CRON_NAME_SEGMENT_PATTERN,
+  normalizeCronExpression
 };

package/dist/{chunk-FSQMN2MQ.mjs → chunk-E46NXBNJ.mjs}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-QSTRBKHZ.mjs";
 import {
   parseBodySizeLimit
-} from "./chunk-GFT5AHAT.mjs";
+} from "./chunk-QDWMCFTH.mjs";
 import {
   subscribeFarmCacheInvalidation,
   subscribeFarmCacheTask

package/dist/{chunk-EGVC4LIG.mjs → chunk-E4RDMG3K.mjs}

@@ -20,7 +20,7 @@ import {
 } from "./chunk-2I6PUKWJ.mjs";
 import {
   withFarmRequestClientAddress
-} from "./chunk-GFT5AHAT.mjs";
+} from "./chunk-QDWMCFTH.mjs";
 import {
   _withFarmResponseHeaders
 } from "./chunk-LM55GS4R.mjs";

package/dist/{chunk-X2CZTWQA.mjs → chunk-ECKQFEX2.mjs}

@@ -29,7 +29,7 @@ import {
 } from "./chunk-F3N52U7S.mjs";
 import {
   getIntegrationSchemas
-} from "./chunk-IFHPDLIS.mjs";
+} from "./chunk-TGULJSHD.mjs";
 
 // src/schema-dependencies.ts
 function collectSchemaDependencies(owners) {