@farm.js/core 0.1.30 → 0.1.34

package/dist/chunk-3BU22U3M.cjs

@@ -0,0 +1,237 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkAI7QMY7Ocjs = require('./chunk-AI7QMY7O.cjs');
+
+
+var _chunkUXFQ3UDAcjs = require('./chunk-UXFQ3UDA.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/middleware/server.ts
+var _async_hooks = require('async_hooks');
+var MIDDLEWARE_DATA_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareDataStore");
+var MIDDLEWARE_CONTEXT_STORE_KEY = /* @__PURE__ */ Symbol.for("farm.middlewareContextStore");
+function getGlobalMiddlewareStore(key) {
+  const state = globalThis;
+  const existing = state[key];
+  if (existing instanceof _async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const store = new (0, _async_hooks.AsyncLocalStorage)();
+  state[key] = store;
+  return store;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getGlobalMiddlewareStore, "getGlobalMiddlewareStore");
+var middlewareStore = getGlobalMiddlewareStore(MIDDLEWARE_DATA_STORE_KEY);
+var middlewareContextStore = getGlobalMiddlewareStore(MIDDLEWARE_CONTEXT_STORE_KEY);
+function toMiddlewareMap(data) {
+  if (data instanceof Map) {
+    return new Map(data);
+  }
+  return new Map(Object.entries(data));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toMiddlewareMap, "toMiddlewareMap");
+function _clearCurrentMiddlewareData() {
+  middlewareStore.enterWith(/* @__PURE__ */ new Map());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareData, "_clearCurrentMiddlewareData");
+function _clearCurrentMiddlewareContext() {
+  middlewareContextStore.enterWith(/* @__PURE__ */ new Map());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _clearCurrentMiddlewareContext, "_clearCurrentMiddlewareContext");
+async function _runWithMiddlewareData(data, fn) {
+  return middlewareStore.run(toMiddlewareMap(data), fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareData, "_runWithMiddlewareData");
+async function _runWithMiddlewareContext(context, fn) {
+  return middlewareContextStore.run(toMiddlewareMap(context), fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithMiddlewareContext, "_runWithMiddlewareContext");
+function getMiddlewareData() {
+  return middlewareStore.getStore() || /* @__PURE__ */ new Map();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareData, "getMiddlewareData");
+function getMiddlewareValue(key) {
+  const data = getMiddlewareData();
+  return data.get(key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareValue, "getMiddlewareValue");
+function getMiddlewareContext() {
+  return middlewareContextStore.getStore() || /* @__PURE__ */ new Map();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getMiddlewareContext, "getMiddlewareContext");
+
+// src/middleware/cookie-header.ts
+function parseMiddlewareCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  for (const cookie of _chunkAI7QMY7Ocjs.parseRequestCookieHeader.call(void 0, cookieHeader)) {
+    if (!Object.prototype.hasOwnProperty.call(cookies, cookie.name)) {
+      cookies[cookie.name] = cookie.value;
+    }
+  }
+  return cookies;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseMiddlewareCookieHeader, "parseMiddlewareCookieHeader");
+function applyCookieNamePrefixRequirements(name, options) {
+  if (name.startsWith("__Host-")) {
+    return { ...options, secure: true, path: "/", domain: void 0 };
+  }
+  if (name.startsWith("__Secure-")) {
+    return { ...options, secure: true };
+  }
+  return options;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyCookieNamePrefixRequirements, "applyCookieNamePrefixRequirements");
+function serializeMiddlewareCookie(name, value, options = {}) {
+  const resolved = applyCookieNamePrefixRequirements(name, options);
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (resolved.maxAge != null) cookie += `; Max-Age=${resolved.maxAge}`;
+  if (resolved.expires) cookie += `; Expires=${resolved.expires.toUTCString()}`;
+  cookie += `; Path=${resolved.path || "/"}`;
+  if (resolved.domain) cookie += `; Domain=${resolved.domain}`;
+  if (resolved.secure || resolved.sameSite === "none") cookie += "; Secure";
+  if (resolved.httpOnly) cookie += "; HttpOnly";
+  if (resolved.sameSite) {
+    cookie += `; SameSite=${resolved.sameSite.charAt(0).toUpperCase()}${resolved.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeMiddlewareCookie, "serializeMiddlewareCookie");
+function serializeMiddlewareCookieDeletion(name, options = {}) {
+  return serializeMiddlewareCookie(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, serializeMiddlewareCookieDeletion, "serializeMiddlewareCookieDeletion");
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isWebRequest, "isWebRequest");
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return _chunkUXFQ3UDAcjs.createWebRequestFromFarmRequest.call(void 0, ctx.request, { origin: ctx.url.origin });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toWebRequest, "toWebRequest");
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createRequestMiddlewareContext, "createRequestMiddlewareContext");
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module = middlewareModule;
+  const defaultExport = module.default;
+  const namedExport = module.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(_optionalChain([built, 'optionalAccess', _ => _.handlers])) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module.config || _optionalChain([built, 'optionalAccess', _2 => _2.config])
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module.config
+    };
+  }
+  return null;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeMiddlewareModule, "normalizeMiddlewareModule");
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports._clearCurrentMiddlewareData = _clearCurrentMiddlewareData; exports._clearCurrentMiddlewareContext = _clearCurrentMiddlewareContext; exports._runWithMiddlewareData = _runWithMiddlewareData; exports._runWithMiddlewareContext = _runWithMiddlewareContext; exports.getMiddlewareData = getMiddlewareData; exports.getMiddlewareValue = getMiddlewareValue; exports.getMiddlewareContext = getMiddlewareContext; exports.parseMiddlewareCookieHeader = parseMiddlewareCookieHeader; exports.serializeMiddlewareCookie = serializeMiddlewareCookie; exports.serializeMiddlewareCookieDeletion = serializeMiddlewareCookieDeletion; exports.normalizeMiddlewareModule = normalizeMiddlewareModule;

package/dist/{chunk-MM5D6VLP.mjs → chunk-3KZS4SUS.mjs}

@@ -6,12 +6,13 @@ import {
 } from "./chunk-FUZEBRP3.mjs";
 import {
   getCurrentRequestOrNull
-} from "./chunk-BSPQVJ4A.mjs";
+} from "./chunk-FDR64H6B.mjs";
 import {
   __name
 } from "./chunk-LPEX4YW6.mjs";
 
 // src/plugins/infra-analytics.ts
+import { AsyncLocalStorage } from "async_hooks";
 var FARM_PRERENDER_ENV = "FARM_PRERENDER";
 var DEFAULT_URL = "https://app.farmjs.dev";
 var EVENTS_PATH = "/api/telemetry/v1/events";
@@ -265,6 +266,20 @@ function requestEvent(metadata, method, status, durationMs) {
   };
 }
 __name(requestEvent, "requestEvent");
+function toolEvent(metadata, event) {
+  return {
+    id: uuid(),
+    requestId: metadata.id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    route: metadata.route,
+    agent: metadata.agent,
+    kind: "mcp.tool",
+    tool: event.tool,
+    outcome: event.outcome,
+    durationMs: duration(event.durationMs)
+  };
+}
+__name(toolEvent, "toolEvent");
 function farmInfraAnalyticsPlugin(options, send) {
   const contextKey = `${CONTEXT_KEY}.${uuid()}`;
   return {
@@ -288,17 +303,7 @@ function farmInfraAnalyticsPlugin(options, send) {
             if (!request) return;
             const metadata = context.requestContext.get(request, contextKey);
             if (!metadata) return;
-            exporter.enqueue({
-              id: uuid(),
-              requestId: metadata.id,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              route: metadata.route,
-              agent: metadata.agent,
-              kind: "mcp.tool",
-              tool: event.tool,
-              outcome: event.outcome,
-              durationMs: duration(event.durationMs)
-            });
+            exporter.enqueue(toolEvent(metadata, event));
             metadata.waitUntil(exporter.flush());
           },
           { unfiltered: true }
@@ -333,6 +338,17 @@ function farmInfraAnalyticsPlugin(options, send) {
 __name(farmInfraAnalyticsPlugin, "farmInfraAnalyticsPlugin");
 function farmInfraAnalyticsRecorder(options, send) {
   const exporter = createFarmInfraAnalyticsExporter(options, send);
+  const requests = new AsyncLocalStorage();
+  const unsubscribe = onFarmEvent(
+    (event) => {
+      if (!isToolEvent(event)) return;
+      const metadata = requests.getStore();
+      if (!metadata) return;
+      exporter.enqueue(toolEvent(metadata, event));
+      metadata.waitUntil(exporter.flush());
+    },
+    { unfiltered: true }
+  );
   return {
     async record(request, runtime, waitUntil, handler) {
       if (runtime.kind === "asset") return handler();
@@ -342,7 +358,7 @@ function farmInfraAnalyticsRecorder(options, send) {
       const startedAt = performance.now();
       let response;
       try {
-        response = await handler();
+        response = await requests.run(metadata, handler);
       } catch (error) {
         background(exporter.flush());
         throw error;
@@ -355,7 +371,10 @@ function farmInfraAnalyticsRecorder(options, send) {
       background(exporter.flush());
       return response;
     },
-    close: /* @__PURE__ */ __name(() => exporter.close(), "close")
+    close() {
+      unsubscribe();
+      return exporter.close();
+    }
   };
 }
 __name(farmInfraAnalyticsRecorder, "farmInfraAnalyticsRecorder");