@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-DRFADSKY.mjs

@@ -0,0 +1,697 @@
+import {
+  normalizeMiddlewareModule,
+  parseMiddlewareCookieHeader,
+  serializeMiddlewareCookie,
+  serializeMiddlewareCookieDeletion
+} from "./chunk-KPAJWD3N.mjs";
+import {
+  compileMiddlewareConfig,
+  compileMiddlewareRoute,
+  matchesMiddlewareConfig,
+  matchesMiddlewareConfigAt,
+  matchesMiddlewareRouteAt,
+  toMiddlewareRoutePathname
+} from "./chunk-EDPENAVO.mjs";
+import {
+  emitFarmEvent
+} from "./chunk-2DA7CLY7.mjs";
+import {
+  withFarmRequestClientAddress
+} from "./chunk-C6U66WWF.mjs";
+import {
+  createFarmAPIMiddlewarePathnames
+} from "./chunk-LM2YOGDK.mjs";
+import {
+  _withFarmResponseHeaders
+} from "./chunk-LM55GS4R.mjs";
+import {
+  getFarmRedirectError,
+  isFarmNotFoundError,
+  isFarmRedirectError
+} from "./chunk-JNYFXL7X.mjs";
+import {
+  stripFarmLocaleFromPathname
+} from "./chunk-7S7AAK2D.mjs";
+import {
+  stripFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/middleware/production-runtime.ts
+var FARM_SET_COOKIE_HEADERS = /* @__PURE__ */ Symbol("farm.setCookieHeaders");
+var WebResponseHeaderMap = class extends Map {
+  constructor() {
+    super(...arguments);
+    this.setCookies = [];
+  }
+  set(key, value) {
+    if (key.toLowerCase() === "set-cookie") {
+      this.setCookies = [value];
+      super.set("Set-Cookie", value);
+      return this;
+    }
+    return super.set(key, value);
+  }
+  delete(key) {
+    if (key.toLowerCase() === "set-cookie") {
+      this.setCookies = [];
+      return super.delete("Set-Cookie") || super.delete("set-cookie");
+    }
+    return super.delete(key);
+  }
+  clear() {
+    this.setCookies = [];
+    super.clear();
+  }
+  appendSetCookie(value) {
+    this.setCookies.push(value);
+    super.set("Set-Cookie", value);
+  }
+  replaceSetCookies(values) {
+    this.setCookies = [...values];
+    super.delete("Set-Cookie");
+    super.delete("set-cookie");
+    if (this.setCookies.length > 0) {
+      super.set("Set-Cookie", this.setCookies[this.setCookies.length - 1]);
+    }
+  }
+  getSetCookies() {
+    return this.setCookies;
+  }
+};
+var WebCookieJar = class {
+  constructor(request, headers) {
+    this.headers = headers;
+    this.cookies = parseMiddlewareCookieHeader(request.headers.get("cookie"));
+  }
+  get(name) {
+    return this.cookies[name];
+  }
+  set(name, value, options = {}) {
+    this.cookies[name] = value;
+    const cookieString = serializeMiddlewareCookie(name, value, options);
+    this.headers.appendSetCookie(cookieString);
+  }
+  delete(name, options = {}) {
+    delete this.cookies[name];
+    this.headers.appendSetCookie(serializeMiddlewareCookieDeletion(name, options));
+  }
+  getAll() {
+    return { ...this.cookies };
+  }
+};
+function mapToHeaders(map) {
+  const headers = new Headers();
+  for (const [key, value] of map) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    headers.set(key, value);
+  }
+  for (const cookie of map.getSetCookies()) {
+    headers.append("Set-Cookie", cookie);
+  }
+  return headers;
+}
+function headersToRecord(headers) {
+  return Object.fromEntries(headers);
+}
+function isMiddlewareResponse(value) {
+  return value instanceof Response;
+}
+function findHeaderName(headers, name) {
+  const normalizedName = name.toLowerCase();
+  return [...headers.keys()].find((key) => key.toLowerCase() === normalizedName);
+}
+function createResponseShim(headers) {
+  const bodyChunks = [];
+  const encoder = new TextEncoder();
+  const response = {
+    headersSent: false,
+    writableEnded: false,
+    statusCode: 200,
+    statusMessage: "",
+    setHeader(name, value) {
+      const existingName = findHeaderName(headers, name);
+      if (existingName) headers.delete(existingName);
+      if (name.toLowerCase() === "set-cookie") {
+        headers.replaceSetCookies(Array.isArray(value) ? value.map(String) : [String(value)]);
+      } else {
+        headers.set(name, Array.isArray(value) ? value.join(", ") : String(value));
+      }
+      return this;
+    },
+    getHeader(name) {
+      if (name.toLowerCase() === "set-cookie") {
+        const cookies = headers.getSetCookies();
+        return cookies.length > 0 ? [...cookies] : void 0;
+      }
+      const existingName = findHeaderName(headers, name);
+      return existingName ? headers.get(existingName) : void 0;
+    },
+    hasHeader(name) {
+      return name.toLowerCase() === "set-cookie" ? headers.getSetCookies().length > 0 : findHeaderName(headers, name) !== void 0;
+    },
+    getHeaderNames() {
+      return [...headers.keys()].map((name) => name.toLowerCase());
+    },
+    getHeaders() {
+      return Object.fromEntries(
+        [...headers.keys()].map((name) => [name.toLowerCase(), this.getHeader(name)])
+      );
+    },
+    removeHeader(name) {
+      const existingName = findHeaderName(headers, name);
+      if (existingName) headers.delete(existingName);
+    },
+    appendHeader(name, value) {
+      const values = Array.isArray(value) ? value.map(String) : [String(value)];
+      if (name.toLowerCase() === "set-cookie") {
+        for (const item of values) headers.appendSetCookie(item);
+        return this;
+      }
+      const existing = this.getHeader(name);
+      return this.setHeader(name, existing ? `${String(existing)}, ${values.join(", ")}` : values);
+    },
+    writeHead(status, statusMessageOrHeaders, responseHeaders) {
+      this.statusCode = status;
+      const nextHeaders = typeof statusMessageOrHeaders === "string" ? responseHeaders : statusMessageOrHeaders;
+      if (typeof statusMessageOrHeaders === "string") {
+        this.statusMessage = statusMessageOrHeaders;
+      }
+      if (nextHeaders) {
+        for (const [key, value] of Object.entries(nextHeaders)) {
+          this.setHeader(key, value);
+        }
+      }
+      this.headersSent = true;
+      return this;
+    },
+    flushHeaders() {
+      this.headersSent = true;
+    },
+    write(chunk, encodingOrCallback, callback) {
+      bodyChunks.push(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+      this.headersSent = true;
+      const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+      done?.();
+      return true;
+    },
+    end(chunk, encodingOrCallback, callback) {
+      if (typeof chunk === "string" || chunk instanceof Uint8Array) {
+        bodyChunks.push(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+      }
+      this.headersSent = true;
+      this.writableEnded = true;
+      const done = typeof chunk === "function" ? chunk : typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+      done?.();
+      return this;
+    }
+  };
+  return {
+    response,
+    getResponse(method) {
+      if (!response.headersSent && !response.writableEnded) return null;
+      const bodyLength = bodyChunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+      const body = new Uint8Array(bodyLength);
+      let offset = 0;
+      for (const chunk of bodyChunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      const bodyAllowed = method.toUpperCase() !== "HEAD" && response.statusCode !== 204 && response.statusCode !== 205 && response.statusCode !== 304;
+      return new Response(bodyAllowed && bodyLength > 0 ? body : null, {
+        status: response.statusCode,
+        statusText: response.statusMessage || void 0,
+        headers: mapToHeaders(headers)
+      });
+    }
+  };
+}
+function createHandledResponse(body, init, headers) {
+  const responseHeaders = new Headers();
+  for (const [key, value] of headers) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    responseHeaders.set(key, value);
+  }
+  for (const [key, value] of new Headers(init.headers)) {
+    responseHeaders.set(key, value);
+  }
+  for (const cookie of headers.getSetCookies()) {
+    responseHeaders.append("Set-Cookie", cookie);
+  }
+  return new Response(body, { ...init, headers: responseHeaders });
+}
+function createWebMiddlewareContext(request, parent, trustProxy = false, clientAddress, toRoutePathname) {
+  let currentRequest = withFarmRequestClientAddress(request, trustProxy, clientAddress);
+  let handledResponse = null;
+  const url = new URL(currentRequest.url);
+  const data = parent?.data ? new Map(parent.data) : /* @__PURE__ */ new Map();
+  const locals = parent?.locals ? new Map(parent.locals) : /* @__PURE__ */ new Map();
+  const headers = new WebResponseHeaderMap();
+  if (parent?.headers) {
+    for (const [key, value] of Object.entries(parent.headers)) {
+      if (key.toLowerCase() === "set-cookie") continue;
+      headers.set(key, value);
+    }
+  }
+  const parentCookies = parent?.[FARM_SET_COOKIE_HEADERS];
+  if (parentCookies) headers.replaceSetCookies(parentCookies);
+  const responseShim = createResponseShim(headers);
+  const ctx = {
+    request: currentRequest,
+    response: responseShim.response,
+    url,
+    pathname: url.pathname,
+    routePathname: toMiddlewareRoutePathname(url.pathname, toRoutePathname),
+    searchParams: url.searchParams,
+    method: currentRequest.method || "GET",
+    params: {},
+    route: url.pathname,
+    parent,
+    vite: {
+      isDev: false,
+      hmr: false
+    },
+    data,
+    locals,
+    headers,
+    cookies: new WebCookieJar(currentRequest, headers),
+    _handled: false,
+    _redirectUrl: void 0,
+    _rewriteUrl: void 0,
+    redirect(redirectUrl, status = 307) {
+      ctx._redirectUrl = redirectUrl;
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        `Redirecting to ${redirectUrl}`,
+        {
+          status,
+          headers: {
+            Location: redirectUrl,
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    rewrite(rewriteUrl) {
+      ctx._rewriteUrl = rewriteUrl;
+      const nextUrl = new URL(rewriteUrl, currentRequest.url);
+      currentRequest = withFarmRequestClientAddress(
+        new Request(nextUrl, currentRequest),
+        trustProxy,
+        clientAddress
+      );
+      ctx.request = currentRequest;
+      ctx.url = nextUrl;
+      ctx.pathname = nextUrl.pathname;
+      ctx.routePathname = toMiddlewareRoutePathname(nextUrl.pathname, toRoutePathname);
+      ctx.searchParams = nextUrl.searchParams;
+      ctx.route = nextUrl.pathname;
+    },
+    json(jsonData, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        JSON.stringify(jsonData),
+        {
+          status,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        },
+        headers
+      );
+    },
+    text(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/plain"
+          }
+        },
+        headers
+      );
+    },
+    html(content, status = 200) {
+      ctx._handled = true;
+      handledResponse = createHandledResponse(
+        content,
+        {
+          status,
+          headers: {
+            "Content-Type": "text/html"
+          }
+        },
+        headers
+      );
+    }
+  };
+  return {
+    ctx,
+    headers,
+    getRequest: () => currentRequest,
+    getResponse: () => handledResponse || responseShim.getResponse(currentRequest.method)
+  };
+}
+function matchesMiddlewareConfig2(pathname, config, ctx) {
+  return matchesMiddlewareConfig(pathname, config, ctx);
+}
+function getConfigHandlers(entry) {
+  const handlers = [];
+  if ("handler" in entry && typeof entry.handler === "function") {
+    handlers.push(entry.handler);
+  }
+  if ("handlers" in entry && Array.isArray(entry.handlers)) {
+    handlers.push(...entry.handlers.filter((handler) => typeof handler === "function"));
+  }
+  return handlers;
+}
+function toMiddlewareConfig(entry) {
+  const { matcher, exclude, runtime, cache } = entry;
+  return { matcher, exclude, runtime, cache };
+}
+function normalizeConfigMiddleware(config) {
+  const entries = [];
+  let globalConfig;
+  if (!config) {
+    return { entries, globalConfig };
+  }
+  const configEntries = Array.isArray(config) ? config : [config];
+  for (const [index, entry] of configEntries.entries()) {
+    const handlers = getConfigHandlers(entry);
+    const middlewareConfig = toMiddlewareConfig(entry);
+    if (handlers.length === 0) {
+      globalConfig = middlewareConfig;
+      continue;
+    }
+    compileMiddlewareConfig(middlewareConfig);
+    entries.push({
+      path: "/",
+      filePath: `farm.config.ts#middleware-${index}`,
+      handlers,
+      config: middlewareConfig,
+      source: "config"
+    });
+  }
+  return { entries, globalConfig };
+}
+function normalizeFileMiddleware(modules = []) {
+  const entries = [];
+  for (const moduleEntry of modules) {
+    const normalized = normalizeMiddlewareModule(moduleEntry.module, moduleEntry.path);
+    if (!normalized) {
+      continue;
+    }
+    if (normalized.config) compileMiddlewareConfig(normalized.config);
+    entries.push({
+      path: moduleEntry.path,
+      filePath: moduleEntry.filePath || moduleEntry.path,
+      handlers: normalized.handlers,
+      config: normalized.config,
+      source: "file"
+    });
+  }
+  return entries;
+}
+async function executeHandlers(handlers, ctx) {
+  let handlerIndex = 0;
+  let returnedResponse;
+  const executeNext = async () => {
+    if (handlerIndex < handlers.length) {
+      const handler = handlers[handlerIndex++];
+      const result2 = await handler(ctx, executeNext);
+      if (isMiddlewareResponse(result2)) {
+        returnedResponse = result2;
+        return result2;
+      }
+    }
+    return returnedResponse;
+  };
+  const result = await executeNext();
+  return isMiddlewareResponse(result) ? result : returnedResponse;
+}
+function emptyResult(request) {
+  return {
+    request,
+    response: null,
+    data: /* @__PURE__ */ new Map(),
+    context: /* @__PURE__ */ new Map(),
+    headers: new Headers(),
+    handled: false,
+    guarded: false
+  };
+}
+function createProductionMiddlewareRunner(options = {}) {
+  const configMiddleware = normalizeConfigMiddleware(options.config);
+  const fileMiddleware = normalizeFileMiddleware(options.modules);
+  for (const entry of fileMiddleware) compileMiddlewareRoute(entry);
+  const entries = [...configMiddleware.entries, ...fileMiddleware];
+  const globalConfig = configMiddleware.globalConfig;
+  if (globalConfig) compileMiddlewareConfig(globalConfig);
+  const toMiddlewarePathnames = createFarmAPIMiddlewarePathnames(options.apiBasePath);
+  return async function runProductionMiddleware(request, requestOptions = {}) {
+    if (!globalConfig && entries.length === 0) {
+      return emptyResult(request);
+    }
+    const toRoutePathname = (pathname) => options.i18n?.enabled ? stripFarmLocaleFromPathname(pathname, options.i18n) : stripFarmBasePath(pathname, options.i18n?.basePath ?? "/");
+    let contextState = createWebMiddlewareContext(
+      request,
+      void 0,
+      options.server?.trustProxy === true,
+      requestOptions.clientAddress,
+      toRoutePathname
+    );
+    let ctx = contextState.ctx;
+    let currentRequest = contextState.getRequest();
+    const initialRequestPathname = ctx.pathname;
+    const initialPathname = toRoutePathname(initialRequestPathname);
+    const matchPathnames = (pathname, requestPathname) => options.rawPathRouting && requestPathname !== pathname ? [
+      .../* @__PURE__ */ new Set([
+        ...toMiddlewarePathnames(pathname),
+        ...toMiddlewarePathnames(requestPathname)
+      ])
+    ] : toMiddlewarePathnames(pathname);
+    let parentData;
+    if (globalConfig) {
+      const globalMatch = matchesMiddlewareConfigAt(
+        matchPathnames(initialPathname, initialRequestPathname),
+        globalConfig,
+        ctx
+      );
+      if (!globalMatch.matched) {
+        return emptyResult(request);
+      }
+      if (globalMatch.params) {
+        ctx.params = { ...ctx.params, ...globalMatch.params };
+      }
+    }
+    const ran = /* @__PURE__ */ new Set();
+    let guarded = false;
+    function* applicableMiddleware() {
+      for (let pathname = initialPathname, requestPathname = initialRequestPathname, pass = 0; ; pass++) {
+        const pathnames = matchPathnames(pathname, requestPathname);
+        if (pass > 0 && globalConfig) {
+          if (!matchesMiddlewareConfigAt(pathnames, globalConfig, ctx).matched) return;
+        }
+        for (const entry of entries) {
+          if (ran.has(entry)) continue;
+          const routeMatch = entry.source === "config" ? { matched: true } : matchesMiddlewareRouteAt(pathnames, entry);
+          if (routeMatch.matched) yield { entry, routeMatch, pathname, pathnames };
+        }
+        const rewrittenRequestPathname = new URL(currentRequest.url).pathname;
+        const rewrittenPathname = toRoutePathname(rewrittenRequestPathname);
+        if (rewrittenPathname === pathname && rewrittenRequestPathname === requestPathname) return;
+        pathname = rewrittenPathname;
+        requestPathname = rewrittenRequestPathname;
+      }
+    }
+    for (const { entry, routeMatch, pathname, pathnames } of applicableMiddleware()) {
+      const configMatch = entry.config ? matchesMiddlewareConfigAt(pathnames, entry.config, ctx) : { matched: true };
+      if (!configMatch.matched) {
+        continue;
+      }
+      ran.add(entry);
+      if (entry.config?.cache !== "public") guarded = true;
+      if (parentData) {
+        contextState = createWebMiddlewareContext(
+          currentRequest,
+          parentData,
+          options.server?.trustProxy === true,
+          requestOptions.clientAddress,
+          toRoutePathname
+        );
+        ctx = contextState.ctx;
+      }
+      if (routeMatch.params) {
+        ctx.params = { ...ctx.params, ...routeMatch.params };
+      }
+      if (configMatch.params) {
+        ctx.params = { ...ctx.params, ...configMatch.params };
+      }
+      const middlewareStartTime = Date.now();
+      const middlewareEvent = {
+        route: entry.path,
+        pathname,
+        name: entry.filePath
+      };
+      emitFarmEvent({ type: "middleware.start", ...middlewareEvent });
+      try {
+        const returnedResponse = await executeHandlers(entry.handlers, ctx);
+        currentRequest = contextState.getRequest();
+        if (returnedResponse) {
+          const response = applyProductionMiddlewareHeaders(
+            returnedResponse,
+            mapToHeaders(contextState.headers)
+          );
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true,
+            guarded
+          };
+        }
+        if (ctx._handled || ctx.response.headersSent || ctx.response.writableEnded) {
+          const response = contextState.getResponse() || new Response(null);
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true,
+            guarded
+          };
+        }
+        emitFarmEvent({
+          type: "middleware.complete",
+          ...middlewareEvent,
+          durationMs: Date.now() - middlewareStartTime
+        });
+      } catch (error) {
+        currentRequest = contextState.getRequest();
+        if (isFarmRedirectError(error)) {
+          const redirect = getFarmRedirectError(error);
+          const response = applyProductionMiddlewareHeaders(
+            new Response(null, { status: redirect.status, headers: { Location: redirect.url } }),
+            mapToHeaders(contextState.headers)
+          );
+          emitFarmEvent({
+            type: "middleware.shortCircuit",
+            ...middlewareEvent,
+            status: response.status
+          });
+          return {
+            request: currentRequest,
+            response,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true,
+            guarded
+          };
+        }
+        if (isFarmNotFoundError(error)) {
+          emitFarmEvent({ type: "middleware.shortCircuit", ...middlewareEvent, status: 404 });
+          return {
+            request: currentRequest,
+            response: null,
+            data: new Map(ctx.data),
+            context: new Map(ctx.locals),
+            headers: mapToHeaders(contextState.headers),
+            handled: true,
+            guarded,
+            notFound: true
+          };
+        }
+        emitFarmEvent({
+          type: "middleware.error",
+          ...middlewareEvent,
+          error
+        });
+        throw error;
+      }
+      parentData = {
+        data: new Map(ctx.data),
+        locals: new Map(ctx.locals),
+        headers: headersToRecord(contextState.headers),
+        [FARM_SET_COOKIE_HEADERS]: [...contextState.headers.getSetCookies()]
+      };
+    }
+    return {
+      request: currentRequest,
+      response: null,
+      data: new Map(ctx.data),
+      context: new Map(ctx.locals),
+      headers: mapToHeaders(contextState.headers),
+      handled: false,
+      guarded
+    };
+  };
+}
+function applyProductionMiddlewareHeaders(response, middlewareHeaders) {
+  if (!middlewareHeaders || Array.from(middlewareHeaders.keys()).length === 0) {
+    return response;
+  }
+  const getSetCookie = middlewareHeaders.getSetCookie;
+  const setCookies = getSetCookie ? getSetCookie.call(middlewareHeaders) : middlewareHeaders.get("set-cookie") ? [middlewareHeaders.get("set-cookie")] : [];
+  return _withFarmResponseHeaders(response, (headers) => {
+    for (const [key, value] of middlewareHeaders) {
+      const name = key.toLowerCase();
+      if (name === "set-cookie") continue;
+      if (name === "vary") {
+        const values = /* @__PURE__ */ new Map();
+        for (const entry of [headers.get("vary"), value].flatMap(
+          (list) => list ? list.split(",") : []
+        )) {
+          const field = entry.trim();
+          if (field && !values.has(field.toLowerCase())) values.set(field.toLowerCase(), field);
+        }
+        headers.set("Vary", Array.from(values.values()).join(", "));
+        continue;
+      }
+      if (headers.has(key)) continue;
+      headers.set(key, value);
+    }
+    for (const cookie of setCookies) {
+      headers.append("Set-Cookie", cookie);
+    }
+  });
+}
+var PRIVATE_CACHE_DIRECTIVE = /(?:^|,)\s*(?:private|no-store)\s*(?:[,=]|$)/i;
+var CDN_CACHE_CONTROL_HEADERS = [
+  "cdn-cache-control",
+  "vercel-cdn-cache-control",
+  "netlify-cdn-cache-control",
+  "cloudflare-cdn-cache-control"
+];
+function _withFarmGuardedResponseCache(response) {
+  const shareable = !PRIVATE_CACHE_DIRECTIVE.test(response.headers.get("cache-control") ?? "");
+  if (!shareable && !CDN_CACHE_CONTROL_HEADERS.some((name) => response.headers.has(name))) {
+    return response;
+  }
+  return _withFarmResponseHeaders(response, (headers) => {
+    if (shareable) headers.set("Cache-Control", "private, no-store");
+    for (const name of CDN_CACHE_CONTROL_HEADERS) headers.delete(name);
+  });
+}
+
+export {
+  matchesMiddlewareConfig2 as matchesMiddlewareConfig,
+  createProductionMiddlewareRunner,
+  applyProductionMiddlewareHeaders,
+  _withFarmGuardedResponseCache
+};