@farm.js/core 0.1.0-beta.97 → 0.1.0-beta.99

package/dist/integrations.cjs

@@ -392,9 +392,13 @@ function getStorage(namespace) {
   const namespaced = (0, import_unstorage.prefixStorage)(globalStorage, base);
   return {
     ...namespaced,
-    async clear() {
-      const keys = await namespaced.getKeys();
-      await Promise.all(keys.map((key) => namespaced.removeItem(key)));
+    // Scope the wipe to the namespace instead of the whole storage, and keep
+    // the caller's base so `clear("sessions")` cannot take unrelated keys with
+    // it. Dropping the argument silently widens a targeted clear into a
+    // namespace-wide delete.
+    async clear(base2, opts) {
+      const keys = await namespaced.getKeys(base2);
+      await Promise.all(keys.map((key) => namespaced.removeItem(key, opts)));
     }
   };
 }
@@ -664,6 +668,7 @@ __export(integrations_exports, {
   defineIntegrationAPI: () => defineIntegrationAPI,
   defineIntegrationAPIOperation: () => defineIntegrationAPIOperation,
   defineIntegrationSchema: () => defineIntegrationSchema,
+  describeIntegrationOriginRejection: () => describeIntegrationOriginRejection,
   dispatchIntegrationRequest: () => dispatchIntegrationRequest,
   getFarmIntegrationPluginOwner: () => getFarmIntegrationPluginOwner,
   getFarmIntegrationPluginServerRuntime: () => getFarmIntegrationPluginServerRuntime,
@@ -679,7 +684,9 @@ __export(integrations_exports, {
   isFarmIntegrationProviderComponentReference: () => isFarmIntegrationProviderComponentReference,
   matchIntegrationRoute: () => matchIntegrationRoute,
   matchRegisteredIntegrationRoute: () => matchRegisteredIntegrationRoute,
-  resolveIntegrationPlugins: () => resolveIntegrationPlugins
+  resolveIntegrationAllowedOrigins: () => resolveIntegrationAllowedOrigins,
+  resolveIntegrationPlugins: () => resolveIntegrationPlugins,
+  validateIntegrationRequestOrigin: () => validateIntegrationRequestOrigin
 });
 module.exports = __toCommonJS(integrations_exports);
 
@@ -864,6 +871,159 @@ function validateConfigRouteSource(source, field = "Config route source") {
 }
 __name(validateConfigRouteSource, "validateConfigRouteSource");
 
+// src/request-origin.ts
+function getRequestSourceOrigin(request) {
+  const origin = request.headers.get("origin")?.trim();
+  if (origin) {
+    return parseSourceOrigin(origin);
+  }
+  const referer = request.headers.get("referer")?.trim();
+  if (referer) {
+    return parseSourceOrigin(referer);
+  }
+  return { ok: true, origin: null };
+}
+__name(getRequestSourceOrigin, "getRequestSourceOrigin");
+function parseSourceOrigin(value) {
+  if (value === "null") {
+    return { ok: false, reason: "opaque-origin" };
+  }
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { ok: false, reason: "invalid-origin" };
+    }
+    return { ok: true, origin: parsed.origin };
+  } catch {
+    return { ok: false, reason: "invalid-origin" };
+  }
+}
+__name(parseSourceOrigin, "parseSourceOrigin");
+function matchesHostHeader(sourceOrigin, request) {
+  const host = request.headers.get("host")?.trim().toLowerCase();
+  if (!host) return false;
+  try {
+    const source = new URL(sourceOrigin);
+    const target = new URL(request.url);
+    return source.protocol === target.protocol && source.host.toLowerCase() === host;
+  } catch {
+    return false;
+  }
+}
+__name(matchesHostHeader, "matchesHostHeader");
+function matchesAllowedOrigin(sourceOrigin, pattern) {
+  const source = new URL(sourceOrigin);
+  if (!pattern.includes("*")) {
+    return pattern.includes("://") ? source.origin === pattern : source.host === pattern;
+  }
+  const schemeEnd = pattern.indexOf("://");
+  const scheme = schemeEnd === -1 ? null : pattern.slice(0, schemeEnd + 1);
+  const hostPattern = pattern.slice(schemeEnd === -1 ? 0 : schemeEnd + 3);
+  const [wildcardHost, port] = splitHostAndPort(hostPattern);
+  const baseHost = wildcardHost.slice(2);
+  if (scheme && source.protocol !== scheme) return false;
+  if (port && getEffectivePort(source) !== port) return false;
+  if (!port && source.port) return false;
+  return source.hostname.endsWith(`.${baseHost}`) && source.hostname !== baseHost;
+}
+__name(matchesAllowedOrigin, "matchesAllowedOrigin");
+function normalizeAllowedOriginPattern(value, label) {
+  const pattern = value.trim().toLowerCase();
+  if (!pattern) {
+    throw new TypeError(`${label} cannot contain empty values`);
+  }
+  if (pattern.includes("*")) {
+    if (!/^(?:https?:\/\/)?\*\.[a-z0-9.-]+(?::\d+)?$/.test(pattern)) {
+      throw new TypeError(`Invalid ${label} pattern: ${JSON.stringify(value)}`);
+    }
+    return pattern;
+  }
+  if (pattern.includes("://")) {
+    let parsed;
+    try {
+      parsed = new URL(pattern);
+    } catch {
+      throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      throw new TypeError(`${label} must contain origins without paths: ${JSON.stringify(value)}`);
+    }
+    return parsed.origin;
+  }
+  if (/[/@?#]/.test(pattern)) {
+    throw new TypeError(`${label} must contain origins or hosts: ${JSON.stringify(value)}`);
+  }
+  try {
+    return new URL(`http://${pattern}`).host;
+  } catch {
+    throw new TypeError(`Invalid ${label} value: ${JSON.stringify(value)}`);
+  }
+}
+__name(normalizeAllowedOriginPattern, "normalizeAllowedOriginPattern");
+function splitHostAndPort(value) {
+  const separator = value.lastIndexOf(":");
+  if (separator === -1) return [value, null];
+  return [value.slice(0, separator), value.slice(separator + 1)];
+}
+__name(splitHostAndPort, "splitHostAndPort");
+function getEffectivePort(url) {
+  if (url.port) return url.port;
+  if (url.protocol === "https:") return "443";
+  if (url.protocol === "http:") return "80";
+  return "";
+}
+__name(getEffectivePort, "getEffectivePort");
+
+// src/integration-request-security.ts
+function resolveIntegrationAllowedOrigins(values, label) {
+  return Object.freeze((values ?? []).map((value) => normalizeAllowedOriginPattern(value, label)));
+}
+__name(resolveIntegrationAllowedOrigins, "resolveIntegrationAllowedOrigins");
+function validateIntegrationRequestOrigin(request, policy = {}) {
+  const allowedOrigins = policy.allowedOrigins ?? [];
+  const requireOriginMetadata = policy.requireOriginMetadata ?? true;
+  const fetchSite = request.headers.get("sec-fetch-site")?.trim().toLowerCase();
+  const source = getRequestSourceOrigin(request);
+  if (!source.ok) {
+    return { ok: false, reason: source.reason };
+  }
+  if (source.origin === null) {
+    if (fetchSite === "same-origin") {
+      return { ok: true };
+    }
+    if (requireOriginMetadata) {
+      return { ok: false, reason: fetchSite === "cross-site" ? "cross-site" : "missing-origin" };
+    }
+    return fetchSite === "cross-site" ? { ok: false, reason: "cross-site" } : { ok: true };
+  }
+  const requestUrl = new URL(request.url);
+  const matchesConfiguredOrigin = allowedOrigins.some(
+    (pattern) => matchesAllowedOrigin(source.origin, pattern)
+  );
+  const matchesRequest = source.origin === requestUrl.origin || matchesHostHeader(source.origin, request);
+  if (!matchesRequest && !matchesConfiguredOrigin) {
+    return { ok: false, reason: "cross-site" };
+  }
+  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
+    return { ok: false, reason: "cross-site" };
+  }
+  return { ok: true };
+}
+__name(validateIntegrationRequestOrigin, "validateIntegrationRequestOrigin");
+function describeIntegrationOriginRejection(reason) {
+  switch (reason) {
+    case "missing-origin":
+      return "Request is missing same-origin metadata.";
+    case "opaque-origin":
+      return "Opaque origins are not allowed.";
+    case "invalid-origin":
+      return "Invalid request origin.";
+    case "cross-site":
+      return "Cross-site request was rejected.";
+  }
+}
+__name(describeIntegrationOriginRejection, "describeIntegrationOriginRejection");
+
 // src/integration-api.ts
 function defineIntegrationAPIOperation(operation2) {
   return {
@@ -3554,6 +3714,7 @@ __name(normalizeMatcher, "normalizeMatcher");
   defineIntegrationAPI,
   defineIntegrationAPIOperation,
   defineIntegrationSchema,
+  describeIntegrationOriginRejection,
   dispatchIntegrationRequest,
   getFarmIntegrationPluginOwner,
   getFarmIntegrationPluginServerRuntime,
@@ -3569,6 +3730,8 @@ __name(normalizeMatcher, "normalizeMatcher");
   isFarmIntegrationProviderComponentReference,
   matchIntegrationRoute,
   matchRegisteredIntegrationRoute,
-  resolveIntegrationPlugins
+  resolveIntegrationAllowedOrigins,
+  resolveIntegrationPlugins,
+  validateIntegrationRequestOrigin
 });
 //# sourceMappingURL=integrations.cjs.map