@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-4WVJLURN.mjs

@@ -1,417 +0,0 @@
-import {
-  getRequestSourceOrigin,
-  matchesAllowedOrigin,
-  matchesHostHeader,
-  normalizeAllowedOriginPattern
-} from "./chunk-FP2INE7H.mjs";
-import {
-  parseBodySizeLimit
-} from "./chunk-ZMMBIVQM.mjs";
-import {
-  subscribeFarmCacheInvalidation,
-  subscribeFarmCacheTask
-} from "./chunk-4SIYUGRY.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/server-action-security.ts
-import { AsyncLocalStorage } from "async_hooks";
-
-// src/server-fn-error.ts
-var FARM_SERVER_FN_FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn.failure");
-var _ServerFnFailure = class _ServerFnFailure extends Error {
-  constructor(code, data, options) {
-    super(options.message);
-    this.name = "ServerFnFailure";
-    this.code = code;
-    this.data = data;
-    this.status = options.status;
-    Object.defineProperty(this, FARM_SERVER_FN_FAILURE_SYMBOL, {
-      value: true,
-      enumerable: false
-    });
-  }
-};
-__name(_ServerFnFailure, "ServerFnFailure");
-var ServerFnFailure = _ServerFnFailure;
-var _ServerActionError = class _ServerActionError extends Error {
-  constructor(message = "Server function failed") {
-    super(message);
-    this.name = "ServerActionError";
-  }
-};
-__name(_ServerActionError, "ServerActionError");
-var ServerActionError = _ServerActionError;
-function isServerFnFailure(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return candidate[FARM_SERVER_FN_FAILURE_SYMBOL] === true && candidate.name === "ServerFnFailure" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599;
-}
-__name(isServerFnFailure, "isServerFnFailure");
-function serializeServerFnFailure(value) {
-  if (!isServerFnFailure(value)) return null;
-  return {
-    name: "ServerFnFailure",
-    message: value.message,
-    code: value.code,
-    status: value.status,
-    data: value.data
-  };
-}
-__name(serializeServerFnFailure, "serializeServerFnFailure");
-function createServerFnTransportError(value) {
-  if (isSerializedServerFnFailure(value)) {
-    return new ServerFnFailure(value.code, value.data, {
-      status: value.status,
-      message: value.message
-    });
-  }
-  const message = value && typeof value === "object" && "message" in value && typeof value.message === "string" ? value.message : "Server function failed";
-  return new ServerActionError(message);
-}
-__name(createServerFnTransportError, "createServerFnTransportError");
-function isSerializedServerFnFailure(value) {
-  if (!value || typeof value !== "object") return false;
-  const candidate = value;
-  return candidate.name === "ServerFnFailure" && typeof candidate.message === "string" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599 && "data" in candidate;
-}
-__name(isSerializedServerFnFailure, "isSerializedServerFnFailure");
-
-// src/server-action-security.ts
-var SERVER_ACTION_ALLOWED_ORIGINS_LABEL = "serverActions.allowedOrigins";
-var DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1e6;
-var _ServerActionRequestError = class _ServerActionRequestError extends Error {
-  constructor(code, status, message) {
-    super(message);
-    this.name = "ServerActionRequestError";
-    this.code = code;
-    this.status = status;
-  }
-};
-__name(_ServerActionRequestError, "ServerActionRequestError");
-var ServerActionRequestError = _ServerActionRequestError;
-var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
-var FALLBACK_ABORT_CONTROLLER_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionFallbackAbortController");
-var FORM_ACTION_CONTENT_TYPES = /* @__PURE__ */ new Set([
-  "application/x-www-form-urlencoded",
-  "multipart/form-data"
-]);
-var JAVASCRIPT_ACTION_CONTENT_TYPES = /* @__PURE__ */ new Set([
-  "application/octet-stream",
-  "application/x-www-form-urlencoded",
-  "multipart/form-data",
-  "text/plain"
-]);
-function resolveServerActionsConfig(config) {
-  const allowedOrigins = (config?.allowedOrigins ?? []).map(
-    (value) => normalizeAllowedOriginPattern(value, SERVER_ACTION_ALLOWED_ORIGINS_LABEL)
-  );
-  const bodySizeLimit = parseBodySizeLimit(
-    config?.bodySizeLimit ?? DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT,
-    "serverActions.bodySizeLimit"
-  );
-  return Object.freeze({
-    allowedOrigins: Object.freeze(allowedOrigins),
-    bodySizeLimit
-  });
-}
-__name(resolveServerActionsConfig, "resolveServerActionsConfig");
-function validateServerActionRequest(request, config) {
-  if (request.method.toUpperCase() !== "POST") {
-    throw new ServerActionRequestError(
-      "INVALID_METHOD",
-      405,
-      "Server actions only accept POST requests"
-    );
-  }
-  const requestUrl = new URL(request.url);
-  const sourceOrigin = resolveSourceOrigin(request);
-  const fetchSite = request.headers.get("sec-fetch-site")?.trim().toLowerCase();
-  if (!sourceOrigin) {
-    if (fetchSite !== "same-origin") {
-      throw new ServerActionRequestError(
-        "MISSING_ORIGIN",
-        403,
-        "Server action request is missing same-origin metadata"
-      );
-    }
-    return;
-  }
-  const matchesRequest = sourceOrigin === requestUrl.origin || matchesHostHeader(sourceOrigin, request);
-  const matchesConfiguredOrigin = config.allowedOrigins.some(
-    (pattern) => matchesAllowedOrigin(sourceOrigin, pattern)
-  );
-  if (!matchesRequest && !matchesConfiguredOrigin) {
-    throw new ServerActionRequestError(
-      "INVALID_ORIGIN",
-      403,
-      "Server action origin does not match the request origin"
-    );
-  }
-  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
-    throw new ServerActionRequestError(
-      "INVALID_ORIGIN",
-      403,
-      "Cross-site server action request was rejected"
-    );
-  }
-}
-__name(validateServerActionRequest, "validateServerActionRequest");
-async function prepareServerActionRequest(request, config, kind, actionId) {
-  validateServerActionRequest(request, config);
-  if (kind === "javascript") {
-    validateActionId(actionId);
-  }
-  const contentType = getSupportedContentType(request, kind);
-  const bytes = await readBodyWithLimit(request, config.bodySizeLimit);
-  if (kind === "form" || contentType === "multipart/form-data") {
-    return {
-      body: await parseFormData(request, bytes),
-      contentType
-    };
-  }
-  return {
-    body: new TextDecoder().decode(bytes),
-    contentType
-  };
-}
-__name(prepareServerActionRequest, "prepareServerActionRequest");
-function createServerActionRequestErrorResponse(error) {
-  if (!(error instanceof ServerActionRequestError)) {
-    return null;
-  }
-  const headers = new Headers({
-    "cache-control": "no-store",
-    "content-type": "text/plain; charset=utf-8",
-    "x-content-type-options": "nosniff"
-  });
-  if (error.status === 405) {
-    headers.set("allow", "POST");
-  }
-  return new Response(getPublicErrorMessage(error.status), {
-    status: error.status,
-    headers
-  });
-}
-__name(createServerActionRequestErrorResponse, "createServerActionRequestErrorResponse");
-function sanitizeServerActionError(error) {
-  const declaredFailure = serializeServerFnFailure(error);
-  if (declaredFailure) return declaredFailure;
-  return {
-    name: "ServerActionError",
-    message: "Server function failed"
-  };
-}
-__name(sanitizeServerActionError, "sanitizeServerActionError");
-async function runWithServerActionRequest(request, callback) {
-  throwIfAborted(request.signal);
-  const context = {
-    request,
-    signal: request.signal,
-    invalidations: /* @__PURE__ */ new Set(),
-    cacheTasks: /* @__PURE__ */ new Set()
-  };
-  return getServerActionStorage().run(context, async () => {
-    try {
-      const result = await callback();
-      await Promise.all(context.cacheTasks);
-      return result;
-    } catch (error) {
-      await Promise.allSettled(context.cacheTasks);
-      throw error;
-    }
-  });
-}
-__name(runWithServerActionRequest, "runWithServerActionRequest");
-function getServerActionExecutionContext() {
-  return getServerActionStorage().getStore();
-}
-__name(getServerActionExecutionContext, "getServerActionExecutionContext");
-function getServerActionSignal() {
-  return getServerActionExecutionContext()?.signal ?? getFallbackAbortController().signal;
-}
-__name(getServerActionSignal, "getServerActionSignal");
-function getServerActionInvalidations() {
-  return Array.from(getServerActionExecutionContext()?.invalidations ?? []);
-}
-__name(getServerActionInvalidations, "getServerActionInvalidations");
-subscribeFarmCacheInvalidation((key) => {
-  getServerActionExecutionContext()?.invalidations.add(key);
-});
-subscribeFarmCacheTask((task) => {
-  getServerActionExecutionContext()?.cacheTasks.add(task);
-});
-function getServerActionStorage() {
-  const globalState = globalThis;
-  if (!globalState[SERVER_ACTION_STORAGE_KEY]) {
-    globalState[SERVER_ACTION_STORAGE_KEY] = new AsyncLocalStorage();
-  }
-  return globalState[SERVER_ACTION_STORAGE_KEY];
-}
-__name(getServerActionStorage, "getServerActionStorage");
-function getFallbackAbortController() {
-  const globalState = globalThis;
-  if (!globalState[FALLBACK_ABORT_CONTROLLER_KEY]) {
-    globalState[FALLBACK_ABORT_CONTROLLER_KEY] = new AbortController();
-  }
-  return globalState[FALLBACK_ABORT_CONTROLLER_KEY];
-}
-__name(getFallbackAbortController, "getFallbackAbortController");
-function resolveSourceOrigin(request) {
-  const result = getRequestSourceOrigin(request);
-  if (!result.ok) {
-    throw new ServerActionRequestError(
-      "INVALID_ORIGIN",
-      403,
-      result.reason === "opaque-origin" ? "Opaque origins are not allowed" : "Invalid request origin"
-    );
-  }
-  return result.origin;
-}
-__name(resolveSourceOrigin, "resolveSourceOrigin");
-function validateActionId(actionId) {
-  if (!actionId || actionId.length > 4096 || hasControlCharacters(actionId)) {
-    throw new ServerActionRequestError("INVALID_ACTION_ID", 400, "Invalid server action id");
-  }
-}
-__name(validateActionId, "validateActionId");
-function hasControlCharacters(value) {
-  for (let index = 0; index < value.length; index++) {
-    const code = value.charCodeAt(index);
-    if (code <= 31 || code === 127) return true;
-  }
-  return false;
-}
-__name(hasControlCharacters, "hasControlCharacters");
-function getSupportedContentType(request, kind) {
-  const header = request.headers.get("content-type")?.trim().toLowerCase();
-  const contentType = header?.split(";", 1)[0]?.trim() ?? "";
-  const supported = kind === "form" ? FORM_ACTION_CONTENT_TYPES : JAVASCRIPT_ACTION_CONTENT_TYPES;
-  if (!supported.has(contentType)) {
-    throw new ServerActionRequestError(
-      "UNSUPPORTED_CONTENT_TYPE",
-      415,
-      "Unsupported server action content type"
-    );
-  }
-  return contentType;
-}
-__name(getSupportedContentType, "getSupportedContentType");
-async function readBodyWithLimit(request, limit) {
-  const contentLength = request.headers.get("content-length")?.trim();
-  if (contentLength) {
-    if (!/^\d+$/.test(contentLength)) {
-      throw new ServerActionRequestError(
-        "INVALID_CONTENT_LENGTH",
-        400,
-        "Invalid content-length header"
-      );
-    }
-    if (Number(contentLength) > limit) {
-      throw new ServerActionRequestError("BODY_TOO_LARGE", 413, "Server action body is too large");
-    }
-  }
-  throwIfAborted(request.signal);
-  if (!request.body) return new Uint8Array();
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  const cancelBodyRead = /* @__PURE__ */ __name(() => {
-    void reader.cancel(request.signal.reason).catch(() => {
-    });
-  }, "cancelBodyRead");
-  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
-  try {
-    while (true) {
-      throwIfAborted(request.signal);
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        const error = new ServerActionRequestError(
-          "BODY_TOO_LARGE",
-          413,
-          "Server action body is too large"
-        );
-        void reader.cancel(error).catch(() => {
-        });
-        throw error;
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    if (request.signal.aborted) throwIfAborted(request.signal);
-    throw error;
-  } finally {
-    request.signal.removeEventListener("abort", cancelBodyRead);
-    reader.releaseLock();
-  }
-  throwIfAborted(request.signal);
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-__name(readBodyWithLimit, "readBodyWithLimit");
-async function parseFormData(request, bytes) {
-  const body = new ArrayBuffer(bytes.byteLength);
-  new Uint8Array(body).set(bytes);
-  const copy = new Request(request.url, {
-    method: "POST",
-    headers: request.headers,
-    body
-  });
-  try {
-    return await copy.formData();
-  } catch {
-    throw new ServerActionRequestError("INVALID_BODY", 400, "Invalid server action form body");
-  }
-}
-__name(parseFormData, "parseFormData");
-function getPublicErrorMessage(status) {
-  switch (status) {
-    case 400:
-      return "Bad Request";
-    case 403:
-      return "Forbidden";
-    case 405:
-      return "Method Not Allowed";
-    case 413:
-      return "Payload Too Large";
-    case 415:
-      return "Unsupported Media Type";
-    default:
-      return "Server Action Request Failed";
-  }
-}
-__name(getPublicErrorMessage, "getPublicErrorMessage");
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-__name(throwIfAborted, "throwIfAborted");
-
-export {
-  FARM_SERVER_FN_FAILURE_SYMBOL,
-  ServerFnFailure,
-  ServerActionError,
-  isServerFnFailure,
-  createServerFnTransportError,
-  DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT,
-  ServerActionRequestError,
-  resolveServerActionsConfig,
-  validateServerActionRequest,
-  prepareServerActionRequest,
-  createServerActionRequestErrorResponse,
-  sanitizeServerActionError,
-  runWithServerActionRequest,
-  getServerActionExecutionContext,
-  getServerActionSignal,
-  getServerActionInvalidations
-};