@farm.js/core 0.1.28 → 0.1.30

package/dist/{chunk-KXGDXYUC.mjs → chunk-DGXN3L4D.mjs}

@@ -18,6 +18,7 @@ import {
   getAllowedAPIRouteMethods,
   invokeAPIRouteEndpoint,
   matchAPIRouteAtBasePath,
+  mergePluginAPIRoutes,
   resolveAPIRouteEndpoint
 } from "./chunk-X7WVQMIB.mjs";
 import {
@@ -63,6 +64,10 @@ function farmApiPlugin(options = {}) {
   const basePath = options.basePath;
   let apiRoutesCache = /* @__PURE__ */ new Map();
   let apiRouterHandler = null;
+  let projectRoot = process.cwd();
+  let pluginMergedRoutes = null;
+  const servedRoutes = /* @__PURE__ */ __name(() => pluginMergedRoutes ?? apiRoutesCache, "servedRoutes");
+  let routePlugins;
   let discoveryComplete = false;
   let discoveryPromise = null;
   let discoveryError;
@@ -179,7 +184,13 @@ function farmApiPlugin(options = {}) {
     }
   }, "restoreRouteState");
   const createRouter = /* @__PURE__ */ __name(async () => {
-    const totalEndpoints = Array.from(apiRoutesCache.values()).reduce(
+    const plugins = options.plugins ? await (routePlugins ?? (routePlugins = Promise.resolve(options.plugins({ root: projectRoot })))) : [];
+    pluginMergedRoutes = plugins.length ? new Map(
+      mergePluginAPIRoutes([...apiRoutesCache.values()], plugins, void 0, {
+        bodySizeLimit
+      }).map((route) => [route.path, route])
+    ) : null;
+    const totalEndpoints = Array.from(servedRoutes().values()).reduce(
       (sum, route) => sum + route.methods.length,
       0
     );
@@ -189,7 +200,7 @@ function farmApiPlugin(options = {}) {
         const url = new URL(request.url);
         const method = request.method.toUpperCase();
         const pathname = url.pathname;
-        const match = matchAPIRouteAtBasePath(apiRoutesCache, pathname, basePath);
+        const match = matchAPIRouteAtBasePath(servedRoutes(), pathname, basePath);
         if (!match) {
           return new Response(JSON.stringify({ error: "Not Found" }), {
             status: 404,
@@ -223,6 +234,7 @@ function farmApiPlugin(options = {}) {
     name: "@farm.js/core:api",
     enforce: "pre",
     configureServer(server) {
+      projectRoot = server.config.root;
       const discoverFileRoutes = /* @__PURE__ */ __name(async (apiDir) => {
         const fs = await import("fs");
         const path = await import("path");
@@ -368,7 +380,7 @@ function farmApiPlugin(options = {}) {
       }, "recoverFailedDiscovery");
       server.__farmApi__ = {
         getHandler: /* @__PURE__ */ __name(() => apiRouterHandler, "getHandler"),
-        getRoutes: /* @__PURE__ */ __name(() => apiRoutesCache, "getRoutes"),
+        getRoutes: /* @__PURE__ */ __name(() => servedRoutes(), "getRoutes"),
         isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
         waitForDiscovery
       };
@@ -378,7 +390,7 @@ function farmApiPlugin(options = {}) {
           const pathname = url.split("?")[0];
           const method = req.method || "GET";
           if (discoveryPromise) await waitForDiscovery();
-          if (!matchAPIRouteAtBasePath(apiRoutesCache, pathname, basePath)) {
+          if (!matchAPIRouteAtBasePath(servedRoutes(), pathname, basePath)) {
             return next();
           }
           if (!apiRouterHandler) {
@@ -399,7 +411,7 @@ function farmApiPlugin(options = {}) {
             }
             const currentUrl = req.url || url;
             const currentPathname = currentUrl.split("?")[0];
-            if (currentPathname !== pathname && !matchAPIRouteAtBasePath(apiRoutesCache, currentPathname, basePath)) {
+            if (currentPathname !== pathname && !matchAPIRouteAtBasePath(servedRoutes(), currentPathname, basePath)) {
               return next();
             }
             const fullUrl = resolveFarmRequestURL(req);

package/dist/chunk-FJ3M4CUX.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/owned-response.ts
+var OWNED_RESPONSES = /* @__PURE__ */ Symbol.for("farm.ownedResponses");
+function registry() {
+  const state = globalThis;
+  return _nullishCoalesce(state[OWNED_RESPONSES], () => ( (state[OWNED_RESPONSES] = /* @__PURE__ */ new WeakSet())));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, registry, "registry");
+function _markFarmOwnedResponse(response) {
+  registry().add(response);
+  return response;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _markFarmOwnedResponse, "_markFarmOwnedResponse");
+function _isFarmOwnedResponse(response) {
+  return registry().has(response);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _isFarmOwnedResponse, "_isFarmOwnedResponse");
+function _withFarmResponseHeaders(response, edit) {
+  if (registry().has(response)) {
+    try {
+      edit(response.headers);
+      return response;
+    } catch (error) {
+      if (!(error instanceof TypeError)) throw error;
+    }
+  }
+  const headers = new Headers(response.headers);
+  edit(headers);
+  return _markFarmOwnedResponse(
+    new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    })
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _withFarmResponseHeaders, "_withFarmResponseHeaders");
+
+
+
+
+
+exports._markFarmOwnedResponse = _markFarmOwnedResponse; exports._isFarmOwnedResponse = _isFarmOwnedResponse; exports._withFarmResponseHeaders = _withFarmResponseHeaders;

package/dist/chunk-FXEF4PPL.mjs

@@ -0,0 +1,47 @@
+import {
+  __name
+} from "./chunk-LPEX4YW6.mjs";
+
+// src/nitro/native-mcp-source.ts
+function generateNativeMCPPluginSource(mcp) {
+  if (mcp?.enabled !== true) {
+    return { importSource: "", registerSource: "", pluginSource: "" };
+  }
+  return {
+    importSource: `import { createFarmMCPPlugin as __farmCreateMCPPlugin } from "@farm.js/mcp/internal";`,
+    registerSource: `function __farmMCPIsPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function __farmMergeMCPConfig(base, override) {
+  const output = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined) continue;
+    output[key] =
+      __farmMCPIsPlainObject(output[key]) && __farmMCPIsPlainObject(value)
+        ? __farmMergeMCPConfig(output[key], value)
+        : value;
+  }
+  return output;
+}
+
+const farmNativeMCPConfig = farmRuntimeConfigs.reduce((merged, runtimeConfig) => {
+  const value = runtimeConfig?.mcp;
+  if (value === undefined) return merged;
+  if (value === false) return false;
+  return __farmMergeMCPConfig(merged && merged !== false ? merged : {}, value);
+}, undefined);
+const farmNativeMCPPlugin =
+  farmNativeMCPConfig && farmNativeMCPConfig.enabled !== false
+    ? __farmCreateMCPPlugin(farmNativeMCPConfig)
+    : null;`,
+    pluginSource: `...(farmNativeMCPPlugin ? [farmNativeMCPPlugin] : []),`
+  };
+}
+__name(generateNativeMCPPluginSource, "generateNativeMCPPluginSource");
+
+export {
+  generateNativeMCPPluginSource
+};