@farm.js/core 0.1.16 → 0.1.18

package/dist/cron.cjs

@@ -1,502 +1,35 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/cron.ts
-var cron_exports = {};
-__export(cron_exports, {
-  DEFAULT_FARM_CRON_SECRET_ENV: () => DEFAULT_FARM_CRON_SECRET_ENV,
-  FARM_CRON_MANIFEST: () => FARM_CRON_MANIFEST,
-  applyFarmCronVercelCrons: () => applyFarmCronVercelCrons,
-  createFarmCronCloudflareConfig: () => createFarmCronCloudflareConfig,
-  createFarmCronCloudflareTriggers: () => createFarmCronCloudflareTriggers,
-  createFarmCronManifest: () => createFarmCronManifest,
-  createFarmCronVercelCrons: () => createFarmCronVercelCrons,
-  cronRoute: () => cronRoute,
-  isCronRequestAuthorized: () => isCronRequestAuthorized,
-  mergeScheduledTasks: () => mergeScheduledTasks,
-  prepareFarmCronForNitro: () => prepareFarmCronForNitro,
-  resolveCronConfig: () => resolveCronConfig
-});
-module.exports = __toCommonJS(cron_exports);
 
-// src/secret-compare.ts
-function farmSecretsMatch(provided, expected) {
-  if (typeof provided !== "string" || typeof expected !== "string") return false;
-  if (expected.length === 0) return false;
-  let mismatch = provided.length ^ expected.length;
-  const length = Math.max(provided.length, expected.length);
-  for (let index = 0; index < length; index += 1) {
-    const providedCode = index < provided.length ? provided.charCodeAt(index) : 0;
-    const expectedCode = index < expected.length ? expected.charCodeAt(index) : 0;
-    mismatch |= providedCode ^ expectedCode;
-  }
-  return mismatch === 0;
-}
-__name(farmSecretsMatch, "farmSecretsMatch");
 
-// src/utils.ts
-function toPosixPath(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-__name(toPosixPath, "toPosixPath");
 
-// src/utils/runtime-env.ts
-function getFarmRuntimeBindings() {
-  const runtimeBindings = globalThis.__env__;
-  return runtimeBindings && typeof runtimeBindings === "object" ? runtimeBindings : void 0;
-}
-__name(getFarmRuntimeBindings, "getFarmRuntimeBindings");
-function readFarmEnvironmentValue(name) {
-  const runtimeValue = getFarmRuntimeBindings()?.[name];
-  if (typeof runtimeValue === "string") return runtimeValue;
-  return typeof process !== "undefined" ? process.env?.[name] : void 0;
-}
-__name(readFarmEnvironmentValue, "readFarmEnvironmentValue");
 
-// src/cron.ts
-var DEFAULT_FARM_CRON_SECRET_ENV = "CRON_SECRET";
-var FARM_CRON_MANIFEST = "cron-manifest.json";
-var CRON_FIELD_RANGES = [
-  [0, 59, "minute"],
-  [0, 23, "hour"],
-  [1, 31, "day of month"],
-  [1, 12, "month"],
-  [0, 6, "day of week"]
-];
-function resolveCronConfig(cron) {
-  if (isResolvedCronConfig(cron)) return cron;
-  if (!cron) {
-    return {
-      enabled: false,
-      secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
-      jobs: []
-    };
-  }
-  const jobs = [];
-  for (const [name, job] of Object.entries(cron)) {
-    if (!job || typeof job !== "object" || Array.isArray(job)) {
-      throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
-    }
-    if (job.enabled === false) continue;
-    jobs.push(normalizeCronJob(name, job));
-  }
-  return {
-    enabled: jobs.length > 0,
-    secretEnv: DEFAULT_FARM_CRON_SECRET_ENV,
-    jobs
-  };
-}
-__name(resolveCronConfig, "resolveCronConfig");
-async function prepareFarmCronForNitro(config) {
-  const cron = isResolvedCronConfig(config.cron) ? config.cron : resolveCronConfig(config.cron);
-  const root = config.root || process.cwd();
-  const distDir = config.distDir || ".farm";
-  const fs = await import("fs/promises");
-  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 })
-    ]);
-    return {
-      jobs: [],
-      tasks: {},
-      scheduledTasks: {}
-    };
-  }
-  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));
-  for (const job of cron.jobs) {
-    const taskName = getFarmCronTaskName(job.name);
-    const wrapperPath = toPosixPath(path.join(generatedDir, `${wrapperNames.get(job.name)}.mjs`));
-    await fs.writeFile(wrapperPath, createNitroCronTaskWrapper(job, cron.secretEnv), "utf8");
-    tasks[taskName] = {
-      handler: wrapperPath,
-      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
-  };
-}
-__name(prepareFarmCronForNitro, "prepareFarmCronForNitro");
-function createFarmCronManifest(cron) {
-  return {
-    schemaVersion: 1,
-    secretEnv: cron.secretEnv,
-    jobs: cron.jobs.map((job) => ({
-      name: job.name,
-      schedule: job.schedule,
-      path: job.path,
-      description: job.description || null
-    }))
-  };
-}
-__name(createFarmCronManifest, "createFarmCronManifest");
-function createFarmCronVercelCrons(jobs) {
-  return jobs.flatMap(
-    (job) => job.schedule.map((schedule) => ({
-      path: job.path,
-      schedule
-    }))
-  );
-}
-__name(createFarmCronVercelCrons, "createFarmCronVercelCrons");
-function applyFarmCronVercelCrons(vercelConfig, jobs) {
-  const existingCrons = Array.isArray(vercelConfig.crons) ? vercelConfig.crons : [];
-  const seen = new Set(existingCrons.map((cron) => `${cron.path}:${cron.schedule}`));
-  const crons = [...existingCrons];
-  for (const cron of createFarmCronVercelCrons(jobs)) {
-    const key = `${cron.path}:${cron.schedule}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    crons.push(cron);
-  }
-  return crons.length > 0 ? { ...vercelConfig, crons } : vercelConfig;
-}
-__name(applyFarmCronVercelCrons, "applyFarmCronVercelCrons");
-function createFarmCronCloudflareTriggers(jobs) {
-  return [...new Set(jobs.flatMap((job) => job.schedule))];
-}
-__name(createFarmCronCloudflareTriggers, "createFarmCronCloudflareTriggers");
-function createFarmCronCloudflareConfig(jobs) {
-  const crons = createFarmCronCloudflareTriggers(jobs);
-  if (crons.length === 0) return void 0;
-  return {
-    deployConfig: true,
-    wrangler: {
-      triggers: { crons }
-    }
-  };
-}
-__name(createFarmCronCloudflareConfig, "createFarmCronCloudflareConfig");
-function mergeScheduledTasks(...maps) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const map of maps) {
-    for (const [schedule, taskNames] of Object.entries(map || {})) {
-      const current = merged.get(schedule) || [];
-      for (const taskName of Array.isArray(taskNames) ? taskNames : [taskNames]) {
-        if (!current.includes(taskName)) current.push(taskName);
-      }
-      merged.set(schedule, current);
-    }
-  }
-  return Object.fromEntries(
-    [...merged].map(([schedule, taskNames]) => [
-      schedule,
-      taskNames.length === 1 ? taskNames[0] : taskNames
-    ])
-  );
-}
-__name(mergeScheduledTasks, "mergeScheduledTasks");
-function isExplicitDevelopmentEnv() {
-  const nodeEnv = readFarmEnvironmentValue("NODE_ENV");
-  return nodeEnv === "development" || nodeEnv === "test";
-}
-__name(isExplicitDevelopmentEnv, "isExplicitDevelopmentEnv");
-function isCronRequestAuthorized(request, options = {}) {
-  const secretEnv = options.secretEnv || DEFAULT_FARM_CRON_SECRET_ENV;
-  const secret = options.secret || readFarmEnvironmentValue(secretEnv);
-  if (!secret) {
-    return options.allowUnsecured === true || !getFarmRuntimeBindings() && isExplicitDevelopmentEnv();
-  }
-  const authorization = request.headers.get("authorization") || "";
-  const bearer = /^Bearer (.*)$/i.exec(authorization)?.[1] || "";
-  const headerSecret = request.headers.get("x-farm-cron-secret") || "";
-  return farmSecretsMatch(bearer, secret) || farmSecretsMatch(headerSecret, secret);
-}
-__name(isCronRequestAuthorized, "isCronRequestAuthorized");
-function cronRoute(handler, options = {}) {
-  return (request, ...args) => {
-    if (!isCronRequestAuthorized(request, options)) {
-      return Promise.resolve(
-        Response.json({ error: "Unauthorized cron request." }, { status: 401 })
-      );
-    }
-    return handler(request, ...args);
-  };
-}
-__name(cronRoute, "cronRoute");
-function normalizeCronJob(name, job) {
-  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.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.`
-    );
-  }
-  if (!job || typeof job !== "object" || Array.isArray(job)) {
-    throw new TypeError(`Farm cron ${JSON.stringify(name)} must be a configuration object.`);
-  }
-  const path = normalizeCronPath(name, job.path);
-  const rawSchedule = Array.isArray(job.schedule) ? job.schedule : [job.schedule];
-  const schedule = [...new Set(rawSchedule.map((value) => normalizeCronExpression(name, value)))];
-  if (schedule.length === 0) {
-    throw new TypeError(`Farm cron ${JSON.stringify(name)} must define at least one schedule.`);
-  }
-  return {
-    name,
-    schedule,
-    path,
-    description: job.description?.trim() || void 0
-  };
-}
-__name(normalizeCronJob, "normalizeCronJob");
-function normalizeCronPath(name, value) {
-  if (typeof value !== "string" || !value.trim().startsWith("/")) {
-    throw new TypeError(`Farm cron ${JSON.stringify(name)} path must start with "/".`);
-  }
-  const hasUnstableCharacters = /* @__PURE__ */ __name((candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  }), "hasUnstableCharacters");
-  if (hasUnstableCharacters(value)) {
-    throw new TypeError(
-      `Farm cron ${JSON.stringify(name)} path cannot contain backslashes or control characters.`
-    );
-  }
-  const path = value.trim();
-  if (path.startsWith("//") || path.includes("?") || path.includes("#")) {
-    throw new TypeError(
-      `Farm cron ${JSON.stringify(name)} path must be an application pathname without a host, query, or hash.`
-    );
-  }
-  for (const segment of path.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new TypeError(
-        `Farm cron ${JSON.stringify(name)} path cannot contain backslashes or control characters.`
-      );
-    }
-    if (decoded.includes("/")) {
-      throw new TypeError(
-        `Farm cron ${JSON.stringify(name)} path cannot contain percent-encoded path separators.`
-      );
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new TypeError(
-        `Farm cron ${JSON.stringify(name)} path cannot contain "." or ".." path segments.`
-      );
-    }
-  }
-  return path.length > 1 ? path.replace(/\/+$/, "") : path;
-}
-__name(normalizeCronPath, "normalizeCronPath");
-function normalizeCronExpression(name, value) {
-  if (typeof value !== "string") {
-    throw new TypeError(`Farm cron ${JSON.stringify(name)} schedule must be a string.`);
-  }
-  const expression = value.trim().replace(/\s+/g, " ");
-  const fields = expression.split(" ");
-  if (fields.length !== CRON_FIELD_RANGES.length) {
-    throw new TypeError(
-      `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} must use five fields: minute hour day-of-month month day-of-week.`
-    );
-  }
-  fields.forEach((field, index) => {
-    const [minimum, maximum, label] = CRON_FIELD_RANGES[index];
-    validateCronField(name, expression, field, minimum, maximum, label);
-  });
-  if (fields[2] !== "*" && fields[4] !== "*") {
-    throw new TypeError(
-      `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} cannot constrain both day-of-month and day-of-week.`
-    );
-  }
-  return expression;
-}
-__name(normalizeCronExpression, "normalizeCronExpression");
-function validateCronField(name, expression, field, minimum, maximum, label) {
-  for (const segment of field.split(",")) {
-    const [range, stepText, ...extra] = segment.split("/");
-    if (!range || extra.length > 0 || stepText !== void 0 && !isIntegerInRange(stepText, 1)) {
-      throwInvalidCronField(name, expression, label);
-    }
-    if (range === "*") continue;
-    const bounds = range.split("-");
-    if (bounds.length > 2 || !bounds.every((value) => isIntegerInRange(value, minimum, maximum))) {
-      throwInvalidCronField(name, expression, label);
-    }
-    if (bounds.length === 2 && Number(bounds[0]) > Number(bounds[1])) {
-      throwInvalidCronField(name, expression, label);
-    }
-  }
-}
-__name(validateCronField, "validateCronField");
-function isIntegerInRange(value, minimum, maximum = Number.MAX_SAFE_INTEGER) {
-  if (!/^\d+$/.test(value)) return false;
-  const parsed = Number(value);
-  return parsed >= minimum && parsed <= maximum;
-}
-__name(isIntegerInRange, "isIntegerInRange");
-function throwInvalidCronField(name, expression, label) {
-  throw new TypeError(
-    `Farm cron ${JSON.stringify(name)} schedule ${JSON.stringify(expression)} has an invalid ${label} field.`
-  );
-}
-__name(throwInvalidCronField, "throwInvalidCronField");
-function isResolvedCronConfig(value) {
-  return !!value && typeof value === "object" && "enabled" in value && typeof value.enabled === "boolean" && "jobs" in value && Array.isArray(value.jobs) && "secretEnv" in value;
-}
-__name(isResolvedCronConfig, "isResolvedCronConfig");
-function createCronScheduledTasks(jobs) {
-  const scheduledTasks = {};
-  for (const job of jobs) {
-    const taskName = getFarmCronTaskName(job.name);
-    for (const schedule of job.schedule) {
-      scheduledTasks[schedule] = mergeTaskNames(scheduledTasks[schedule], taskName);
-    }
-  }
-  return scheduledTasks;
-}
-__name(createCronScheduledTasks, "createCronScheduledTasks");
-function mergeTaskNames(current, taskName) {
-  if (!current) return taskName;
-  const names = Array.isArray(current) ? current : [current];
-  return names.includes(taskName) ? names : [...names, taskName];
-}
-__name(mergeTaskNames, "mergeTaskNames");
-function getFarmCronTaskName(name) {
-  return `farm:cron:${name}`;
-}
-__name(getFarmCronTaskName, "getFarmCronTaskName");
-function createNitroCronTaskWrapper(job, secretEnv) {
-  return `
-import { useNitroApp } from "nitro/app";
-import { defineTask } from "nitro/task";
 
-const name = ${JSON.stringify(job.name)};
-const path = ${JSON.stringify(job.path)};
-const secretEnv = ${JSON.stringify(secretEnv)};
 
-function readSecret(event) {
-  const runtimeEnv = event?.context?.cloudflare?.env || event?.context?.env || {};
-  return runtimeEnv[secretEnv] || (typeof process !== "undefined" ? process.env?.[secretEnv] : "") || "";
-}
 
-export default defineTask({
-  meta: {
-    name: ${JSON.stringify(getFarmCronTaskName(job.name))},
-    description: ${JSON.stringify(job.description || `Farm cron ${job.name}`)}
-  },
-  async run(event) {
-    const headers = new Headers({
-      "x-farm-cron-name": name,
-      "x-farm-cron-scheduled-at": String(event?.payload?.scheduledTime || Date.now())
-    });
-    const secret = readSecret(event);
-    if (secret) headers.set("authorization", "Bearer " + secret);
 
-    const response = await useNitroApp().fetch(path, { method: "GET", headers });
-    const contentType = response.headers.get("content-type") || "";
-    const body = response.status === 204
-      ? null
-      : contentType.includes("application/json")
-        ? await response.json().catch(() => null)
-        : await response.text();
 
-    if (!response.ok) {
-      const detail = typeof body === "string" ? body : JSON.stringify(body);
-      throw new Error(
-        "Farm cron " + JSON.stringify(name) + " received " + response.status +
-        " from " + path + (detail ? ": " + detail : "")
-      );
-    }
 
-    return { result: body };
-  }
-});
-`.trim();
-}
-__name(createNitroCronTaskWrapper, "createNitroCronTaskWrapper");
-function resolveCronWrapperFileNames(names) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const key = safeFileName(name).toLowerCase();
-    groups.set(key, (groups.get(key) ?? 0) + 1);
-  }
-  const resolved = /* @__PURE__ */ new Map();
-  const claimed = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const base = safeFileName(name);
-    const key = base.toLowerCase();
-    const fileName = (groups.get(key) ?? 0) > 1 ? `${key}-${cronNameFingerprint(name)}` : base;
-    const claimedBy = claimed.get(fileName.toLowerCase());
-    if (claimedBy !== void 0) {
-      throw new Error(
-        `Farm cron jobs ${JSON.stringify(claimedBy)} and ${JSON.stringify(name)} generate the same wrapper file ${JSON.stringify(`${fileName}.mjs`)}. Rename one of them.`
-      );
-    }
-    claimed.set(fileName.toLowerCase(), name);
-    resolved.set(name, fileName);
-  }
-  return resolved;
-}
-__name(resolveCronWrapperFileNames, "resolveCronWrapperFileNames");
-function cronNameFingerprint(value) {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-__name(cronNameFingerprint, "cronNameFingerprint");
-function safeFileName(value) {
-  return value.replace(/[^a-zA-Z0-9._-]+/g, "-") || "cron";
-}
-__name(safeFileName, "safeFileName");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEFAULT_FARM_CRON_SECRET_ENV,
-  FARM_CRON_MANIFEST,
-  applyFarmCronVercelCrons,
-  createFarmCronCloudflareConfig,
-  createFarmCronCloudflareTriggers,
-  createFarmCronManifest,
-  createFarmCronVercelCrons,
-  cronRoute,
-  isCronRequestAuthorized,
-  mergeScheduledTasks,
-  prepareFarmCronForNitro,
-  resolveCronConfig
-});
+
+var _chunk6EXBPJ24cjs = require('./chunk-6EXBPJ24.cjs');
+require('./chunk-JDNHKPTD.cjs');
+require('./chunk-CMGMGHUZ.cjs');
+require('./chunk-5QIKR7RR.cjs');
+require('./chunk-QNPEUFHQ.cjs');
+require('./chunk-US2QVW3E.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_CRON_SECRET_ENV = _chunk6EXBPJ24cjs.DEFAULT_FARM_CRON_SECRET_ENV; exports.FARM_CRON_MANIFEST = _chunk6EXBPJ24cjs.FARM_CRON_MANIFEST; exports.applyFarmCronVercelCrons = _chunk6EXBPJ24cjs.applyFarmCronVercelCrons; exports.createFarmCronCloudflareConfig = _chunk6EXBPJ24cjs.createFarmCronCloudflareConfig; exports.createFarmCronCloudflareTriggers = _chunk6EXBPJ24cjs.createFarmCronCloudflareTriggers; exports.createFarmCronManifest = _chunk6EXBPJ24cjs.createFarmCronManifest; exports.createFarmCronVercelCrons = _chunk6EXBPJ24cjs.createFarmCronVercelCrons; exports.cronRoute = _chunk6EXBPJ24cjs.cronRoute; exports.isCronRequestAuthorized = _chunk6EXBPJ24cjs.isCronRequestAuthorized; exports.mergeScheduledTasks = _chunk6EXBPJ24cjs.mergeScheduledTasks; exports.prepareFarmCronForNitro = _chunk6EXBPJ24cjs.prepareFarmCronForNitro; exports.resolveCronConfig = _chunk6EXBPJ24cjs.resolveCronConfig;

package/dist/cron.mjs

@@ -11,9 +11,9 @@ import {
   mergeScheduledTasks,
   prepareFarmCronForNitro,
   resolveCronConfig
-} from "./chunk-4L7SZOHZ.mjs";
-import "./chunk-ONUEYC6N.mjs";
+} from "./chunk-YHOCRI4H.mjs";
 import "./chunk-2UC36WAC.mjs";
+import "./chunk-ONUEYC6N.mjs";
 import "./chunk-KI3MESHB.mjs";
 import "./chunk-QVKYGNVM.mjs";
 import "./chunk-CQ6OSQ3K.mjs";