@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-HLYRXN2I.cjs

@@ -0,0 +1,242 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/api/transport.ts
+function multipart(schema) {
+  if (!Object.isExtensible(schema) && !isMultipartSchema(schema)) {
+    throw new TypeError("multipart() requires an extensible schema object");
+  }
+  if (!isMultipartSchema(schema)) {
+    Object.defineProperty(schema, "__farmMultipartSchema", {
+      value: true,
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
+  }
+  return schema;
+}
+function isMultipartSchema(value) {
+  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
+}
+function toFormData(values) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(values)) {
+    if (isUnsafeFormKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) appendFormValue(formData, key, entry);
+      continue;
+    }
+    appendFormValue(formData, key, value);
+  }
+  return formData;
+}
+function jsonStream(source, init = {}) {
+  const iterator = toAsyncIterator(source);
+  const encoder = new TextEncoder();
+  let finished = false;
+  let cleanup;
+  const closeSource = (reason) => _nullishCoalesce(cleanup, () => ( (cleanup = Promise.resolve().then(() => _optionalChain([iterator, 'access', _ => _.return, 'optionalCall', _2 => _2(reason)])))));
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        if (finished) return;
+        try {
+          const next = await iterator.next();
+          if (finished) return;
+          if (next.done) {
+            finished = true;
+            controller.close();
+            return;
+          }
+          const serialized = JSON.stringify(next.value);
+          if (serialized === void 0) {
+            throw new TypeError("Farm JSON stream chunks must be JSON-serializable values");
+          }
+          controller.enqueue(encoder.encode(`${serialized}
+`));
+        } catch (error) {
+          if (finished) return;
+          finished = true;
+          try {
+            await closeSource(error);
+          } catch (e) {
+          }
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        finished = true;
+        await closeSource(reason);
+      }
+    },
+    {
+      // Do not read the next application event until the response consumer
+      // requests another chunk.
+      highWaterMark: 0
+    }
+  );
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/x-ndjson; charset=utf-8");
+  }
+  headers.set("cache-control", _nullishCoalesce(headers.get("cache-control"), () => ( "no-store")));
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
+function isJSONStreamResponse(response) {
+  const contentType = _nullishCoalesce(_optionalChain([response, 'access', _3 => _3.headers, 'optionalAccess', _4 => _4.get, 'optionalCall', _5 => _5("content-type"), 'optionalAccess', _6 => _6.toLowerCase, 'call', _7 => _7()]), () => ( ""));
+  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
+}
+function readJSONStream(response) {
+  if (!response.body) {
+    throw new TypeError("Cannot read a JSON stream response without a body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  let cancelled = false;
+  let claimed = false;
+  let released = false;
+  const releaseReader = () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  };
+  const parseLine = async (line) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      completed = true;
+      buffer = "";
+      void reader.cancel(error).catch(() => {
+      });
+      releaseReader();
+      throw error;
+    }
+  };
+  const readNext = async () => {
+    while (true) {
+      if (cancelled) return { done: true, value: void 0 };
+      const lineEnd = buffer.indexOf("\n");
+      if (lineEnd >= 0) {
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line) continue;
+        return { done: false, value: await parseLine(line) };
+      }
+      if (completed) {
+        const line = buffer.trim();
+        buffer = "";
+        if (!line) {
+          releaseReader();
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: await parseLine(line) };
+      }
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (error) {
+        if (cancelled) return { done: true, value: void 0 };
+        completed = true;
+        buffer = "";
+        releaseReader();
+        throw error;
+      }
+      if (cancelled) return { done: true, value: void 0 };
+      completed = chunk.done;
+      buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+    }
+  };
+  let readQueue = Promise.resolve();
+  const iterator = {
+    next() {
+      const result = readQueue.then(readNext);
+      readQueue = result.then(
+        () => {
+        },
+        () => {
+        }
+      );
+      return result;
+    },
+    async return() {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel();
+        } finally {
+          releaseReader();
+        }
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+  return {
+    response,
+    async cancel(reason) {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel(reason);
+        } finally {
+          releaseReader();
+        }
+      }
+    },
+    [Symbol.asyncIterator]() {
+      if (claimed) {
+        throw new TypeError("Farm API streams can only be consumed once");
+      }
+      claimed = true;
+      return iterator;
+    }
+  };
+}
+function isFarmAPIStream(value) {
+  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function appendFormValue(formData, key, value) {
+  if (value === void 0) return;
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (value instanceof Blob) {
+    formData.append(key, value);
+    return;
+  }
+  if (value instanceof Date) {
+    formData.append(key, value.toISOString());
+    return;
+  }
+  formData.append(key, String(value));
+}
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function toAsyncIterator(source) {
+  if (Symbol.asyncIterator in Object(source)) {
+    return source[Symbol.asyncIterator]();
+  }
+  const iterator = source[Symbol.iterator]();
+  return {
+    next: async () => iterator.next(),
+    return: iterator.return ? async (value) => iterator.return(value) : void 0
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.multipart = multipart; exports.isMultipartSchema = isMultipartSchema; exports.toFormData = toFormData; exports.jsonStream = jsonStream; exports.isJSONStreamResponse = isJSONStreamResponse; exports.readJSONStream = readJSONStream; exports.isFarmAPIStream = isFarmAPIStream;

package/dist/chunk-HNAISJFD.cjs

@@ -0,0 +1,215 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunk3BIASUGRcjs = require('./chunk-3BIASUGR.cjs');
+
+// src/server/request.ts
+var _async_hooks = require('async_hooks');
+var _stream = require('stream');
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+var requestStore = getRequestStore();
+var SHARED_CACHE_SCOPE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/shared-cache-scope");
+function getSharedCacheScopeStore() {
+  const runtime = globalThis;
+  const existing = runtime[SHARED_CACHE_SCOPE_KEY];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) return existing;
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[SHARED_CACHE_SCOPE_KEY] = storage;
+  return storage;
+}
+var sharedCacheScope = getSharedCacheScopeStore();
+_chunk3BIASUGRcjs._setSharedCacheScopeRunner.call(void 0, (label, fn) => sharedCacheScope.run(label, fn));
+function _assertRequestReadAllowed(api) {
+  const scope = sharedCacheScope.getStore();
+  if (!scope) return;
+  throw new Error(
+    `${api} cannot be called inside ${scope}: its result is cached and shared by every request, so one visitor's request data would be served to others. Read it outside the cached function and pass the value in as an argument, which also makes it part of the cache key.`
+  );
+}
+var REQUEST_READS_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-reads");
+function getRequestReads() {
+  const runtime = globalThis;
+  return _nullishCoalesce(runtime[REQUEST_READS_KEY], () => ( (runtime[REQUEST_READS_KEY] = /* @__PURE__ */ new WeakMap())));
+}
+var requestReads = getRequestReads();
+function countRequestRead(request) {
+  requestReads.set(request, (_nullishCoalesce(requestReads.get(request), () => ( 0))) + 1);
+}
+var appRequestViews = /* @__PURE__ */ new WeakMap();
+function getAppRequestView(request) {
+  const existing = appRequestViews.get(request);
+  if (existing) return existing;
+  let view;
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    countRequestRead(request);
+    view = request;
+    try {
+      guardRequestReads(view, request, request.headers, request.clone);
+    } catch (e) {
+    }
+  } else {
+    view = new Request(request);
+    Object.defineProperty(view, "signal", { configurable: true, get: () => request.signal });
+    guardRequestReads(view, request, request.headers, request.clone);
+  }
+  appRequestViews.set(request, view);
+  return view;
+}
+function guardRequestReads(view, request, requestHeaders, clone) {
+  Object.defineProperties(view, {
+    headers: {
+      configurable: true,
+      get() {
+        _assertRequestReadAllowed("request.headers");
+        countRequestRead(request);
+        return requestHeaders;
+      }
+    },
+    clone: {
+      configurable: true,
+      value() {
+        _assertRequestReadAllowed("request.clone()");
+        countRequestRead(request);
+        return clone.call(request);
+      }
+    }
+  });
+}
+_chunk3BIASUGRcjs._setCurrentRequestResolver.call(void 0, 
+  () => {
+    _assertRequestReadAllowed(
+      "A helper that reads the current request (such as auth.user() or the server api client)"
+    );
+    return requestStore.getStore();
+  },
+  () => requestStore.getStore()
+);
+var CSP_NONCE_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/csp-nonce-storage");
+function getCspNonceStore() {
+  const runtime = globalThis;
+  const existing = runtime[CSP_NONCE_STORAGE_KEY];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) return existing;
+  const storage = new (0, _async_hooks.AsyncLocalStorage)();
+  runtime[CSP_NONCE_STORAGE_KEY] = storage;
+  return storage;
+}
+var cspNonceStore = getCspNonceStore();
+_chunk3BIASUGRcjs._setCspNonceResolver.call(void 0, () => cspNonceStore.getStore());
+function _runWithFarmCspNonce(nonce, fn) {
+  return nonce ? cspNonceStore.run(nonce, fn) : fn();
+}
+_chunk3BIASUGRcjs._setAppRequestView.call(void 0, getAppRequestView);
+function resolveFarmRequestURL(req, options = {}) {
+  if (options.origin) {
+    return new URL(req.url || "/", options.origin);
+  }
+  const forwardedHost = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-host"]) : void 0;
+  const fallbackHost = firstForwardedHeaderValue(req.headers.host) || "localhost";
+  const forwardedProto = options.trustProxy ? firstForwardedHeaderValue(req.headers["x-forwarded-proto"]) : void 0;
+  const normalizedProto = _optionalChain([forwardedProto, 'optionalAccess', _ => _.toLowerCase, 'call', _2 => _2()]);
+  const proto = normalizedProto === "https" || normalizedProto === "http" ? normalizedProto : isEncryptedFarmRequest(req) ? "https" : "http";
+  return new URL(req.url || "/", resolveRequestOrigin(proto, forwardedHost, fallbackHost));
+}
+function resolveFarmWebRequestOrigin(request, options = {}) {
+  const url = new URL(request.url);
+  if (!options.trustProxy) return url.origin;
+  const forwardedHost = firstForwardedHeaderValue(
+    _nullishCoalesce(request.headers.get("x-forwarded-host"), () => ( void 0))
+  );
+  const forwardedProto = _optionalChain([firstForwardedHeaderValue, 'call', _3 => _3(
+    _nullishCoalesce(request.headers.get("x-forwarded-proto"), () => ( void 0))
+  ), 'optionalAccess', _4 => _4.toLowerCase, 'call', _5 => _5()]);
+  const proto = forwardedProto === "https" || forwardedProto === "http" ? forwardedProto : url.protocol === "https:" ? "https" : "http";
+  return resolveRequestOrigin(proto, forwardedHost, url.host);
+}
+function createWebRequestFromFarmRequest(req, options = {}) {
+  const fullUrl = resolveFarmRequestURL(req, options).toString();
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value == null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        headers.append(key, item);
+      }
+      continue;
+    }
+    headers.set(key, value);
+  }
+  const method = (req.method || "GET").toUpperCase();
+  const init = {
+    method: req.method,
+    headers
+  };
+  if (method !== "GET" && method !== "HEAD") {
+    init.body = _stream.Readable.toWeb(req);
+    init.duplex = "half";
+  }
+  return new Request(fullUrl, init);
+}
+function isEncryptedFarmRequest(req) {
+  return Boolean(_optionalChain([req, 'access', _6 => _6.socket, 'optionalAccess', _7 => _7.encrypted]));
+}
+function firstForwardedHeaderValue(value) {
+  const first = Array.isArray(value) ? value[0] : value;
+  const token = _optionalChain([first, 'optionalAccess', _8 => _8.split, 'call', _9 => _9(",", 1), 'access', _10 => _10[0], 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]);
+  return token || void 0;
+}
+function resolveRequestOrigin(proto, host, fallback) {
+  for (const candidate of [host, fallback, "localhost"]) {
+    if (!candidate) continue;
+    if (/[\s/?#@\\]/u.test(candidate)) continue;
+    try {
+      const url = new URL(`${proto}://${candidate}`);
+      if (url.username || url.password || url.pathname !== "/" || url.search || url.hash) continue;
+      return url.origin;
+    } catch (e2) {
+    }
+  }
+  return `${proto}://localhost`;
+}
+async function _runWithCurrentRequest(request, fn) {
+  return requestStore.run(request, fn);
+}
+function getCurrentRequest() {
+  _assertRequestReadAllowed("getCurrentRequest()");
+  const request = requestStore.getStore();
+  if (!request) {
+    throw new Error(
+      "No current request is available. getCurrentRequest() can only be used during server rendering."
+    );
+  }
+  countRequestRead(request);
+  return request;
+}
+function _getRequestReadCount(request = requestStore.getStore()) {
+  return request ? _nullishCoalesce(requestReads.get(request), () => ( 0)) : 0;
+}
+function getCurrentRequestOrNull() {
+  return _nullishCoalesce(requestStore.getStore(), () => ( null));
+}
+
+
+
+
+
+
+
+
+
+
+
+exports._assertRequestReadAllowed = _assertRequestReadAllowed; exports._runWithFarmCspNonce = _runWithFarmCspNonce; exports.resolveFarmRequestURL = resolveFarmRequestURL; exports.resolveFarmWebRequestOrigin = resolveFarmWebRequestOrigin; exports.createWebRequestFromFarmRequest = createWebRequestFromFarmRequest; exports._runWithCurrentRequest = _runWithCurrentRequest; exports.getCurrentRequest = getCurrentRequest; exports._getRequestReadCount = _getRequestReadCount; exports.getCurrentRequestOrNull = getCurrentRequestOrNull;