@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-F646BZ4Y.mjs

@@ -1,581 +0,0 @@
-import {
-  createFarmDevServerDispatch
-} from "./chunk-SGBZPZUW.mjs";
-import {
-  _runWithAPIRequestRuntime
-} from "./chunk-R3DS7A2T.mjs";
-import {
-  _withAfterNodeMiddleware
-} from "./chunk-IOEH4VWN.mjs";
-import {
-  APIRouteConflictError
-} from "./chunk-YYQVGKO5.mjs";
-import {
-  findProgrammaticRouteFilesInDir
-} from "./chunk-FWCGUVVL.mjs";
-import {
-  isFarmAPIRouteFileName
-} from "./chunk-CU625VAY.mjs";
-import {
-  API_ROUTE_METHODS,
-  getAllowedAPIRouteMethods,
-  invokeAPIRouteEndpoint,
-  matchAPIRouteAtBasePath,
-  mergePluginAPIRoutes,
-  resolveAPIRouteEndpoint
-} from "./chunk-VTBXE6QG.mjs";
-import {
-  isProgrammaticRoutesFileName
-} from "./chunk-KNHBTJP6.mjs";
-import {
-  createCliColors
-} from "./chunk-I2BHUNBU.mjs";
-import {
-  loadFarmDevModule
-} from "./chunk-QCVIRVHE.mjs";
-import {
-  toPosixPath,
-  toViteModuleId
-} from "./chunk-KI3MESHB.mjs";
-import {
-  sendWebResponse
-} from "./chunk-Z2RZJZIZ.mjs";
-import {
-  createFarmRequestBodyErrorResponse,
-  readNodeRequestBody,
-  resolveFarmServerConfig
-} from "./chunk-ZZGQD7A4.mjs";
-import {
-  resolveFarmRequestURL
-} from "./chunk-X3NGFVRF.mjs";
-import {
-  AmbiguousRouteError,
-  assertUniqueRouteParameters,
-  getRoutePatternShape
-} from "./chunk-55YI3RRB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/api/vite-plugin.ts
-import nodePath from "path";
-function farmApiPlugin(options = {}) {
-  const srcDir = options.srcDir ?? "src";
-  const apiDirFromRoot = options.apiDir ?? nodePath.join(srcDir, "api");
-  const debug = options.debug ?? false;
-  const bodySizeLimit = resolveFarmServerConfig({
-    bodySizeLimit: options.bodySizeLimit
-  }).bodySizeLimit;
-  const basePath = options.basePath;
-  let apiRoutesCache = /* @__PURE__ */ new Map();
-  let apiRouterHandler = null;
-  let projectRoot = process.cwd();
-  let devServer;
-  let pluginMergedRoutes = null;
-  const servedRoutes = /* @__PURE__ */ __name(() => pluginMergedRoutes ?? apiRoutesCache, "servedRoutes");
-  let routePlugins;
-  let discoveryComplete = false;
-  let discoveryPromise = null;
-  let discoveryError;
-  let recoverFailedDiscovery;
-  const endpointSources = /* @__PURE__ */ new Map();
-  const routeShapes = /* @__PURE__ */ new Map();
-  const log = /* @__PURE__ */ __name((_message) => {
-  }, "log");
-  const logResponse = /* @__PURE__ */ __name((method, urlPath, status, duration) => {
-    const pc = createCliColors();
-    let statusColor = pc.green;
-    if (status >= 500) statusColor = pc.red;
-    else if (status >= 400) statusColor = pc.yellow;
-    else if (status >= 300) statusColor = pc.cyan;
-    const logMsg = [
-      pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
-      pc.dim("[") + pc.bold(pc.cyan("API")) + pc.dim("]"),
-      pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
-      pc.gray(urlPath),
-      pc.dim("-"),
-      statusColor(status.toString()),
-      pc.dim(`(${duration}ms)`)
-    ].join(" ");
-    console.log(logMsg);
-  }, "logResponse");
-  const registerRouteShape = /* @__PURE__ */ __name((routePath, filePath) => {
-    assertUniqueRouteParameters(routePath, "api");
-    const shape = getRoutePatternShape(routePath, "api");
-    const existing = routeShapes.get(shape);
-    if (existing && existing.routePath !== routePath) {
-      throw new AmbiguousRouteError(
-        `Ambiguous API routes "${existing.routePath}" and "${routePath}" match the same URLs. Found ${existing.filePath} and ${filePath}. Keep only one route for this URL shape.`
-      );
-    }
-    routeShapes.set(shape, { routePath, filePath });
-  }, "registerRouteShape");
-  const addEndpoint = /* @__PURE__ */ __name((routePath, filePath, method, endpoint) => {
-    registerRouteShape(routePath, filePath);
-    const normalizedMethod = method.toUpperCase();
-    const existing = apiRoutesCache.get(routePath);
-    const existingFile = endpointSources.get(routePath)?.get(normalizedMethod);
-    if (existingFile) {
-      throw new APIRouteConflictError(routePath, normalizedMethod, existingFile, filePath);
-    }
-    if (existing) {
-      if (!existing.methods.includes(normalizedMethod)) {
-        existing.methods.push(normalizedMethod);
-      }
-      existing.endpoints[normalizedMethod] = endpoint;
-      const sources = endpointSources.get(routePath) ?? /* @__PURE__ */ new Map();
-      sources.set(normalizedMethod, filePath);
-      endpointSources.set(routePath, sources);
-      return;
-    }
-    apiRoutesCache.set(routePath, {
-      path: routePath,
-      filePath,
-      methods: [normalizedMethod],
-      endpoints: { [normalizedMethod]: endpoint }
-    });
-    endpointSources.set(routePath, /* @__PURE__ */ new Map([[normalizedMethod, filePath]]));
-  }, "addEndpoint");
-  const removeEndpointsFromFile = /* @__PURE__ */ __name((filePath) => {
-    for (const [routePath, sources] of endpointSources) {
-      const route = apiRoutesCache.get(routePath);
-      if (!route) continue;
-      for (const [method, sourceFile] of sources) {
-        if (sourceFile !== filePath) continue;
-        sources.delete(method);
-        route.methods = route.methods.filter((candidate) => candidate !== method);
-        delete route.endpoints[method];
-      }
-      if (route.methods.length === 0) {
-        apiRoutesCache.delete(routePath);
-        endpointSources.delete(routePath);
-        routeShapes.delete(getRoutePatternShape(routePath, "api"));
-      } else {
-        const currentSource = sources.values().next().value;
-        if (route.filePath === filePath && currentSource) {
-          route.filePath = currentSource;
-        }
-        routeShapes.set(getRoutePatternShape(routePath, "api"), {
-          routePath,
-          filePath: currentSource ?? route.filePath
-        });
-      }
-    }
-  }, "removeEndpointsFromFile");
-  const snapshotRouteState = /* @__PURE__ */ __name(() => ({
-    routes: new Map(
-      [...apiRoutesCache].map(([routePath, route]) => [
-        routePath,
-        {
-          ...route,
-          methods: [...route.methods],
-          endpoints: { ...route.endpoints }
-        }
-      ])
-    ),
-    sources: new Map(
-      [...endpointSources].map(([routePath, sources]) => [routePath, new Map(sources)])
-    ),
-    shapes: new Map(routeShapes)
-  }), "snapshotRouteState");
-  const restoreRouteState = /* @__PURE__ */ __name((snapshot) => {
-    apiRoutesCache = snapshot.routes;
-    endpointSources.clear();
-    for (const [routePath, sources] of snapshot.sources) {
-      endpointSources.set(routePath, sources);
-    }
-    routeShapes.clear();
-    for (const [shape, route] of snapshot.shapes) {
-      routeShapes.set(shape, route);
-    }
-  }, "restoreRouteState");
-  const createRouter = /* @__PURE__ */ __name(async () => {
-    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,
-        // A plugin calling an app endpoint (an MCP tool, say) goes back through this server,
-        // so the middleware that guards the endpoint's path runs for it.
-        dispatch: /* @__PURE__ */ __name((request) => {
-          if (!devServer) throw new Error("The Farm API dev server is not running.");
-          return createFarmDevServerDispatch(devServer)(request);
-        }, "dispatch")
-      }).map((route) => [route.path, route])
-    ) : null;
-    const totalEndpoints = Array.from(servedRoutes().values()).reduce(
-      (sum, route) => sum + route.methods.length,
-      0
-    );
-    apiRouterHandler = null;
-    if (totalEndpoints > 0) {
-      apiRouterHandler = /* @__PURE__ */ __name(async (request) => {
-        const url = new URL(request.url);
-        const method = request.method.toUpperCase();
-        const pathname = url.pathname;
-        const match = matchAPIRouteAtBasePath(servedRoutes(), pathname, basePath);
-        if (!match) {
-          return new Response(JSON.stringify({ error: "Not Found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-        const { route, params } = match;
-        const endpoint = resolveAPIRouteEndpoint(route, method);
-        if (!endpoint) {
-          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
-            status: 405,
-            headers: {
-              Allow: getAllowedAPIRouteMethods(route).join(", "),
-              "Content-Type": "application/json"
-            }
-          });
-        }
-        try {
-          return await invokeAPIRouteEndpoint(endpoint, request, params, bodySizeLimit);
-        } catch (error) {
-          return new Response(JSON.stringify({ error: error.message || "Internal Server Error" }), {
-            status: 500,
-            headers: { "Content-Type": "application/json" }
-          });
-        }
-      }, "apiRouterHandler");
-      log(`API router created with ${totalEndpoints} endpoints`);
-    }
-  }, "createRouter");
-  return {
-    name: "@farm.js/core:api",
-    enforce: "pre",
-    configureServer(server) {
-      projectRoot = server.config.root;
-      devServer = server;
-      const discoverFileRoutes = /* @__PURE__ */ __name(async (apiDir) => {
-        const fs = await import("fs");
-        const path = await import("path");
-        if (!fs.existsSync(apiDir)) {
-          log("No api directory found");
-          return;
-        }
-        const findRouteFiles = /* @__PURE__ */ __name((dir) => {
-          const files = [];
-          if (!fs.existsSync(dir)) return files;
-          const entries = fs.readdirSync(dir, { withFileTypes: true });
-          for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-              files.push(...findRouteFiles(fullPath));
-            } else if (isFarmAPIRouteFileName(entry.name)) {
-              files.push(fullPath);
-            }
-          }
-          return files;
-        }, "findRouteFiles");
-        const routeFiles = findRouteFiles(apiDir);
-        apiRoutesCache.clear();
-        endpointSources.clear();
-        routeShapes.clear();
-        for (const filePath of routeFiles) {
-          try {
-            const relativePath = path.relative(apiDir, path.dirname(filePath));
-            const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
-            const routeModule = await loadFarmDevModule(server, filePath);
-            const endpoints = {};
-            const availableMethods = [];
-            for (const method of API_ROUTE_METHODS) {
-              if (routeModule[method]) {
-                availableMethods.push(method);
-                endpoints[method] = routeModule[method];
-              }
-            }
-            if (availableMethods.length > 0) {
-              for (const method of availableMethods) {
-                addEndpoint(routePath, filePath, method, endpoints[method]);
-              }
-              log(`API route discovered: ${availableMethods.join(", ")} ${routePath}`);
-            }
-          } catch (e) {
-            if (e instanceof APIRouteConflictError || e instanceof AmbiguousRouteError) throw e;
-            log(`API route load failed at ${filePath}: ${e.message}`);
-          }
-        }
-      }, "discoverFileRoutes");
-      const discoverRootRoutes = /* @__PURE__ */ __name(async () => {
-        const fs = await import("fs");
-        const path = await import("path");
-        const routesFiles = [
-          path.join(server.config.root, srcDir, "routes.ts"),
-          path.join(server.config.root, srcDir, "routes.tsx"),
-          path.join(server.config.root, srcDir, "routes.js")
-        ];
-        for (const routesFile of routesFiles) {
-          if (fs.existsSync(routesFile)) {
-            try {
-              const routesModule = await loadFarmDevModule(server, routesFile);
-              for (const [exportName, exportValue] of Object.entries(routesModule)) {
-                const endpoint = exportValue;
-                if (endpoint && endpoint.__path) {
-                  const routePath = endpoint.__path;
-                  const method = String(endpoint.__method || "GET").toUpperCase();
-                  addEndpoint(routePath, routesFile, method, endpoint);
-                  log(`Root route discovered: ${method} ${routePath}`);
-                }
-              }
-            } catch (e) {
-              if (e instanceof APIRouteConflictError || e instanceof AmbiguousRouteError) throw e;
-              log(`Root routes.ts load failed: ${e.message}`);
-            }
-            break;
-          }
-        }
-      }, "discoverRootRoutes");
-      const discoverProgrammaticRoutes = /* @__PURE__ */ __name(async () => {
-        const path = await import("path");
-        const srcRoot = path.join(server.config.root, srcDir);
-        const routeFiles = findProgrammaticRouteFilesInDir(srcRoot);
-        if (routeFiles.length === 0) return;
-        const { getProgrammaticRouteManifest } = await import("./routes.mjs");
-        for (const routeFile of routeFiles) {
-          try {
-            const routesModule = await loadFarmDevModule(
-              server,
-              toViteModuleId(routeFile, server.config.root)
-            );
-            const manifest = getProgrammaticRouteManifest(routesModule);
-            if (!manifest) continue;
-            for (const definition of manifest.routes) {
-              if (definition.kind !== "api") continue;
-              for (const [method, endpoint] of Object.entries(definition.methods)) {
-                if (endpoint) {
-                  addEndpoint(definition.path, routeFile, method, endpoint);
-                  log(`Programmatic route discovered: ${method} ${definition.path}`);
-                }
-              }
-            }
-          } catch (e) {
-            if (e instanceof APIRouteConflictError || e instanceof AmbiguousRouteError) throw e;
-            log(`Programmatic routes file load failed at ${routeFile}: ${e.message}`);
-          }
-        }
-      }, "discoverProgrammaticRoutes");
-      const initializeDiscovery = /* @__PURE__ */ __name(async () => {
-        const path = await import("path");
-        const apiDir = path.join(server.config.root, apiDirFromRoot);
-        log(`Discovering API routes in: ${apiDir}`);
-        await discoverFileRoutes(apiDir);
-        await discoverRootRoutes();
-        await discoverProgrammaticRoutes();
-        await createRouter();
-        discoveryComplete = true;
-        log(`API discovery complete: ${apiRoutesCache.size} routes found`);
-      }, "initializeDiscovery");
-      discoveryPromise = initializeDiscovery().catch((e) => {
-        discoveryError = e;
-        console.error("[FARM] API discovery error:", e);
-      });
-      const waitForDiscovery = /* @__PURE__ */ __name(async () => {
-        await discoveryPromise;
-        if (discoveryError) throw discoveryError;
-      }, "waitForDiscovery");
-      recoverFailedDiscovery = /* @__PURE__ */ __name(async () => {
-        if (!discoveryError) return false;
-        const previousState = snapshotRouteState();
-        try {
-          await initializeDiscovery();
-          discoveryError = void 0;
-          discoveryPromise = Promise.resolve();
-        } catch (error) {
-          restoreRouteState(previousState);
-          discoveryError = error;
-          discoveryComplete = false;
-          discoveryPromise = Promise.resolve();
-          throw error;
-        }
-        return true;
-      }, "recoverFailedDiscovery");
-      server.__farmApi__ = {
-        getHandler: /* @__PURE__ */ __name(() => apiRouterHandler, "getHandler"),
-        getRoutes: /* @__PURE__ */ __name(() => servedRoutes(), "getRoutes"),
-        isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
-        waitForDiscovery
-      };
-      return () => {
-        const apiMiddleware = _withAfterNodeMiddleware(async (req, res, next) => {
-          const url = req.url || "/";
-          const pathname = url.split("?")[0];
-          const method = req.method || "GET";
-          if (discoveryPromise) await waitForDiscovery();
-          if (!matchAPIRouteAtBasePath(servedRoutes(), pathname, basePath)) {
-            return next();
-          }
-          if (!apiRouterHandler) {
-            return next();
-          }
-          const startTime = Date.now();
-          try {
-            const farmMiddleware = server.__farmMiddleware__;
-            if (farmMiddleware) {
-              await farmMiddleware.waitForDiscovery?.();
-              const middlewareData = /* @__PURE__ */ new Map();
-              const handled = await farmMiddleware.execute(req, res, pathname, middlewareData);
-              if (handled) {
-                const duration2 = Date.now() - startTime;
-                logResponse(method, pathname, res.statusCode || 200, duration2);
-                return;
-              }
-            }
-            const currentUrl = req.url || url;
-            const currentPathname = currentUrl.split("?")[0];
-            if (currentPathname !== pathname && !matchAPIRouteAtBasePath(servedRoutes(), currentPathname, basePath)) {
-              return next();
-            }
-            const fullUrl = resolveFarmRequestURL(req);
-            const headers = new Headers();
-            for (const [key, value] of Object.entries(req.headers)) {
-              if (value) {
-                headers.set(key, Array.isArray(value) ? value.join(", ") : value);
-              }
-            }
-            let body;
-            if (method !== "GET" && method !== "HEAD") {
-              body = await readNodeRequestBody(req, bodySizeLimit);
-            }
-            const request = new Request(fullUrl, {
-              method,
-              headers,
-              body: body ? body.buffer.slice(
-                body.byteOffset,
-                body.byteOffset + body.byteLength
-              ) : void 0
-            });
-            const response = await apiRouterHandler(request);
-            const duration = Date.now() - startTime;
-            logResponse(method, currentPathname, response.status, duration);
-            await sendWebResponse(res, response);
-          } catch (error) {
-            const bodyErrorResponse = createFarmRequestBodyErrorResponse(error);
-            if (bodyErrorResponse) {
-              await sendWebResponse(res, bodyErrorResponse);
-              return;
-            }
-            const duration = Date.now() - startTime;
-            logResponse(method, pathname, 500, duration);
-            console.error("[FARM] API error:", error);
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ error: "Internal server error" }));
-          }
-        });
-        server.middlewares.use((req, res, next) => {
-          const result = _runWithAPIRequestRuntime(
-            {
-              basePath: basePath ?? "/api",
-              dispatch: /* @__PURE__ */ __name(async (request) => apiRouterHandler ? apiRouterHandler(request) : Response.json({ error: "Not Found" }, { status: 404 }), "dispatch")
-            },
-            () => apiMiddleware(req, res, next)
-          );
-          return Promise.resolve(result).catch((error) => {
-            console.error(
-              `[FARM] Unhandled API error while handling ${req.method || "GET"} ${req.url || "/"}:`,
-              error
-            );
-            if (res.writableEnded) return;
-            if (res.headersSent) {
-              res.destroy?.(error instanceof Error ? error : new Error(String(error)));
-              return;
-            }
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "application/json");
-            res.end(JSON.stringify({ error: "Internal server error" }));
-          });
-        });
-      };
-    },
-    async handleHotUpdate({ file, server, modules }) {
-      const normalizedFile = toPosixPath(file);
-      const fileName = normalizedFile.split("/").pop() || "";
-      if (fileName === "routes.ts" || fileName === "routes.tsx" || fileName === "routes.js" || isProgrammaticRoutesFileName(fileName)) {
-        log(`Root routes file updated: ${fileName}`);
-        for (const mod of modules) {
-          server.moduleGraph.invalidateModule(mod);
-        }
-        if (await recoverFailedDiscovery?.()) return [];
-        const previousState = snapshotRouteState();
-        try {
-          const routesModule = await loadFarmDevModule(server, file);
-          removeEndpointsFromFile(file);
-          for (const [exportName, exportValue] of Object.entries(routesModule)) {
-            const endpoint = exportValue;
-            if (endpoint && endpoint.__path) {
-              const routePath = endpoint.__path;
-              const method = String(endpoint.__method || "GET").toUpperCase();
-              addEndpoint(routePath, file, method, endpoint);
-              log(`Root route reloaded: ${method} ${routePath}`);
-            }
-          }
-          const { getProgrammaticRouteManifest } = await import("./routes.mjs");
-          const manifest = getProgrammaticRouteManifest(routesModule);
-          if (manifest) {
-            for (const definition of manifest.routes) {
-              if (definition.kind !== "api") continue;
-              for (const [method, endpoint] of Object.entries(definition.methods)) {
-                if (endpoint) {
-                  addEndpoint(definition.path, file, method, endpoint);
-                  log(`Programmatic route reloaded: ${method} ${definition.path}`);
-                }
-              }
-            }
-          }
-          await createRouter();
-          log(`API router recreated`);
-        } catch (e) {
-          restoreRouteState(previousState);
-          if (e instanceof APIRouteConflictError || e instanceof AmbiguousRouteError) throw e;
-          log(`Root routes.ts HMR failed: ${e.message}`);
-        }
-        return [];
-      }
-      if (normalizedFile.includes("/api/") && fileName.startsWith("route.")) {
-        const shortPath = normalizedFile.split("/api/")[1] || normalizedFile;
-        log(`API route updated: ${shortPath}`);
-        for (const mod of modules) {
-          server.moduleGraph.invalidateModule(mod);
-        }
-        if (await recoverFailedDiscovery?.()) return [];
-        const previousState = snapshotRouteState();
-        try {
-          const path = await import("path");
-          const apiDir = path.join(server.config.root, apiDirFromRoot);
-          const relativePath = path.relative(apiDir, path.dirname(file));
-          const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
-          const fs = await import("fs");
-          if (!fs.existsSync(file)) {
-            removeEndpointsFromFile(file);
-            await createRouter();
-            log(`API route file removed: ${routePath}`);
-            return [];
-          }
-          const routeModule = await loadFarmDevModule(server, file);
-          removeEndpointsFromFile(file);
-          const availableMethods = [];
-          for (const method of API_ROUTE_METHODS) {
-            if (!routeModule[method]) continue;
-            availableMethods.push(method);
-            addEndpoint(routePath, file, method, routeModule[method]);
-          }
-          await createRouter();
-          log(`API route reloaded: ${availableMethods.join(", ")} ${routePath}`);
-          log(`API router recreated`);
-        } catch (e) {
-          restoreRouteState(previousState);
-          if (e instanceof APIRouteConflictError || e instanceof AmbiguousRouteError) throw e;
-          log(`API route HMR failed: ${e.message}`);
-        }
-        return [];
-      }
-    }
-  };
-}
-__name(farmApiPlugin, "farmApiPlugin");
-
-export {
-  farmApiPlugin
-};

package/dist/chunk-FA2W42OV.mjs

@@ -1,25 +0,0 @@
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/app-markdown-config.ts
-import path from "path";
-function resolveMdxConfig(config) {
-  return {
-    components: config?.components,
-    markdownRoutes: config?.markdownRoutes ?? true,
-    className: config?.className ?? "farm-markdown"
-  };
-}
-__name(resolveMdxConfig, "resolveMdxConfig");
-function resolveFarmMdxComponentsModulePath(config, root) {
-  const components = config?.components;
-  if (typeof components !== "string") return void 0;
-  return path.isAbsolute(components) ? components : path.join(root, components);
-}
-__name(resolveFarmMdxComponentsModulePath, "resolveFarmMdxComponentsModulePath");
-
-export {
-  resolveMdxConfig,
-  resolveFarmMdxComponentsModulePath
-};