@farm.js/core 0.1.0-beta.0

package/dist/chunk-PRNYWD7K.mjs

@@ -0,0 +1,599 @@
+import {
+  _withAfterNodeMiddleware
+} from "./chunk-E6EPN5BT.mjs";
+import {
+  sendWebResponse
+} from "./chunk-QGOHVJ6J.mjs";
+import {
+  API_ROUTE_METHODS,
+  findProgrammaticRouteFilesInDir
+} from "./chunk-YHU7SS6L.mjs";
+import {
+  toViteModuleId
+} from "./chunk-J4FNJ5IU.mjs";
+import {
+  invokeAPIRouteEndpoint,
+  matchAPIRoute
+} from "./chunk-EVGBEZDF.mjs";
+import {
+  getProgrammaticRouteManifest,
+  isProgrammaticRoutesFileName
+} from "./chunk-B6N4ZB2H.mjs";
+import {
+  __name,
+  __require
+} from "./chunk-CGILA3WO.mjs";
+
+// src/api/endpoint.ts
+import { createEndpoint as betterCallEndpoint } from "better-call";
+function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
+  let path;
+  let options;
+  let handler;
+  if (typeof pathOrOptions === "string") {
+    path = pathOrOptions;
+    options = optionsOrHandler;
+    handler = maybeHandler;
+  } else {
+    path = "";
+    options = pathOrOptions;
+    handler = optionsOrHandler;
+  }
+  if (typeof handler !== "function") {
+    throw new TypeError("createEndpoint requires a handler function");
+  }
+  const middleware = normalizeEndpointMiddleware(options.middleware);
+  const wrappedHandler = /* @__PURE__ */ __name(((ctx) => runEndpointMiddleware(middleware, ctx, handler)), "wrappedHandler");
+  const { middleware: _middleware, ...betterCallOptions } = options;
+  const endpoint = betterCallEndpoint(
+    path || "/__farm_auto_path__",
+    betterCallOptions,
+    wrappedHandler
+  );
+  endpoint.__path = path || void 0;
+  endpoint.__method = options.method || "GET";
+  endpoint.__autoPath = !path;
+  endpoint.__handler = wrappedHandler;
+  endpoint.__middleware = middleware;
+  endpoint.__sourceHandler = handler;
+  endpoint.__types = {
+    body: options.body,
+    query: options.query,
+    headers: options.headers,
+    response: null
+  };
+  return endpoint;
+}
+__name(createEndpoint, "createEndpoint");
+var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
+var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
+var UNSAFE_ENDPOINT_CONTEXT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function normalizeEndpointMiddleware(middleware) {
+  if (middleware === void 0) return EMPTY_ENDPOINT_MIDDLEWARE;
+  if (!Array.isArray(middleware)) {
+    throw new TypeError("createEndpoint middleware must be an array of functions");
+  }
+  const normalized = [...middleware];
+  for (const entry of normalized) {
+    if (typeof entry !== "function") {
+      throw new TypeError("createEndpoint middleware entries must be functions");
+    }
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
+async function runEndpointMiddleware(middleware, handlerContext, handler) {
+  let context = createInitialEndpointContext(handlerContext.context);
+  for (let index = 0; index < middleware.length; index++) {
+    const result = await middleware[index]({ ...handlerContext, context });
+    if (isEndpointResponse(result)) return result;
+    if (result === false) return forbiddenEndpointResponse();
+    if (result === true) continue;
+    if (!isPlainEndpointContext(result)) {
+      throw new TypeError(
+        `Endpoint middleware ${index + 1} must return an object, true, false, or a Response`
+      );
+    }
+    context = mergeEndpointContext(context, result, index);
+  }
+  return handler({ ...handlerContext, context });
+}
+__name(runEndpointMiddleware, "runEndpointMiddleware");
+function createInitialEndpointContext(value) {
+  if (value === void 0 || value === null) return EMPTY_ENDPOINT_CONTEXT;
+  if (!isPlainEndpointContext(value)) {
+    throw new TypeError("Endpoint context must be a plain object");
+  }
+  return mergeEndpointContext(EMPTY_ENDPOINT_CONTEXT, value);
+}
+__name(createInitialEndpointContext, "createInitialEndpointContext");
+function mergeEndpointContext(current, added, middlewareIndex) {
+  const next = Object.assign(/* @__PURE__ */ Object.create(null), current);
+  for (const key of Reflect.ownKeys(added)) {
+    if (!Object.prototype.propertyIsEnumerable.call(added, key)) continue;
+    if (typeof key === "string" && UNSAFE_ENDPOINT_CONTEXT_KEYS.has(key)) {
+      throw new TypeError(`Endpoint middleware cannot provide the unsafe context key "${key}"`);
+    }
+    if (Object.prototype.hasOwnProperty.call(current, key)) {
+      const source = middlewareIndex === void 0 ? "Endpoint context" : `Endpoint middleware ${middlewareIndex + 1}`;
+      throw new TypeError(`${source} cannot replace the existing context key "${String(key)}"`);
+    }
+    next[key] = added[key];
+  }
+  return Object.freeze(next);
+}
+__name(mergeEndpointContext, "mergeEndpointContext");
+function isPlainEndpointContext(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainEndpointContext, "isPlainEndpointContext");
+function isEndpointResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+__name(isEndpointResponse, "isEndpointResponse");
+function forbiddenEndpointResponse() {
+  return new Response(JSON.stringify({ error: "Forbidden" }), {
+    status: 403,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+__name(forbiddenEndpointResponse, "forbiddenEndpointResponse");
+function GET(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "GET" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "GET" }, args[1]);
+}
+__name(GET, "GET");
+function HEAD(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "HEAD" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "HEAD" }, args[1]);
+}
+__name(HEAD, "HEAD");
+function POST(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "POST" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "POST" }, args[1]);
+}
+__name(POST, "POST");
+function PUT(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "PUT" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "PUT" }, args[1]);
+}
+__name(PUT, "PUT");
+function DELETE(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "DELETE" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "DELETE" }, args[1]);
+}
+__name(DELETE, "DELETE");
+function PATCH(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "PATCH" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "PATCH" }, args[1]);
+}
+__name(PATCH, "PATCH");
+function OPTIONS(...args) {
+  if (args.length === 1) {
+    return createEndpoint("", { method: "OPTIONS" }, args[0]);
+  }
+  return createEndpoint("", { ...args[0], method: "OPTIONS" }, args[1]);
+}
+__name(OPTIONS, "OPTIONS");
+
+// src/api/vite-plugin.ts
+function farmApiPlugin(options = {}) {
+  const srcDir = options.srcDir ?? "src";
+  const debug = options.debug ?? false;
+  let apiRoutesCache = /* @__PURE__ */ new Map();
+  let apiRouterHandler = null;
+  let discoveryComplete = false;
+  let discoveryPromise = null;
+  const log = /* @__PURE__ */ __name((_message) => {
+  }, "log");
+  const logResponse = /* @__PURE__ */ __name((method, urlPath, status, duration) => {
+    try {
+      const pc = __require("picocolors");
+      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);
+    } catch {
+      console.log(`[FARM] [API] [${method}] ${urlPath} - ${status} (${duration}ms)`);
+    }
+  }, "logResponse");
+  const addEndpoint = /* @__PURE__ */ __name((routePath, filePath, method, endpoint) => {
+    const normalizedMethod = method.toUpperCase();
+    const existing = apiRoutesCache.get(routePath);
+    if (existing) {
+      if (!existing.methods.includes(normalizedMethod)) {
+        existing.methods.push(normalizedMethod);
+      }
+      existing.endpoints[normalizedMethod] = endpoint;
+      return;
+    }
+    apiRoutesCache.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint }
+    });
+  }, "addEndpoint");
+  const createRouter = /* @__PURE__ */ __name(async () => {
+    const totalEndpoints = Array.from(apiRoutesCache.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 = matchAPIRoute(apiRoutesCache, pathname);
+        if (!match) {
+          return new Response(JSON.stringify({ error: "Not Found" }), {
+            status: 404,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        const { route, params } = match;
+        const endpoint = route.endpoints[method];
+        if (!endpoint) {
+          return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+            status: 405,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+        try {
+          return await invokeAPIRouteEndpoint(endpoint, request, params);
+        } 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) {
+      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 (entry.name === "route.ts" || entry.name === "route.tsx" || entry.name === "route.js") {
+              files.push(fullPath);
+            }
+          }
+          return files;
+        }, "findRouteFiles");
+        const routeFiles = findRouteFiles(apiDir);
+        apiRoutesCache.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 server.ssrLoadModule(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) {
+              apiRoutesCache.set(routePath, {
+                path: routePath,
+                filePath,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`API route discovered: ${availableMethods.join(", ")} ${routePath}`);
+            }
+          } catch (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 server.ssrLoadModule(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) {
+              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);
+        for (const routeFile of routeFiles) {
+          try {
+            const routesModule = await server.ssrLoadModule(
+              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) {
+            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, srcDir, "api");
+        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) => {
+        console.error("[FARM] API discovery error:", e);
+      });
+      server.__farmApi__ = {
+        getHandler: /* @__PURE__ */ __name(() => apiRouterHandler, "getHandler"),
+        getRoutes: /* @__PURE__ */ __name(() => apiRoutesCache, "getRoutes"),
+        isReady: /* @__PURE__ */ __name(() => discoveryComplete, "isReady"),
+        waitForDiscovery: /* @__PURE__ */ __name(() => discoveryPromise, "waitForDiscovery")
+      };
+      return () => {
+        server.middlewares.use(_withAfterNodeMiddleware(async (req, res, next) => {
+          const url = req.url || "/";
+          const pathname = url.split("?")[0];
+          const method = req.method || "GET";
+          if (discoveryPromise && !discoveryComplete) {
+            await discoveryPromise;
+          }
+          if (!matchAPIRoute(apiRoutesCache, pathname)) {
+            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 fullUrl = `http://${req.headers.host || "localhost:3000"}${url}`;
+            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 new Promise((resolve) => {
+                let data = "";
+                req.on("data", (chunk) => {
+                  data += chunk;
+                });
+                req.on("end", () => {
+                  resolve(data);
+                });
+              });
+            }
+            const request = new Request(fullUrl, {
+              method,
+              headers,
+              body: body || void 0
+            });
+            const response = await apiRouterHandler(request);
+            const duration = Date.now() - startTime;
+            logResponse(method, pathname, response.status, duration);
+            await sendWebResponse(res, response);
+          } catch (error) {
+            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" }));
+          }
+        }));
+      };
+    },
+    async handleHotUpdate({ file, server, modules }) {
+      const fileName = file.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);
+        }
+        for (const [routePath, route] of apiRoutesCache) {
+          if (route.filePath === file) {
+            apiRoutesCache.delete(routePath);
+          }
+        }
+        try {
+          const routesModule = await server.ssrLoadModule(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 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) {
+          log(`Root routes.ts HMR failed: ${e.message}`);
+        }
+        return [];
+      }
+      if (file.includes("/api/") && fileName.startsWith("route.")) {
+        const shortPath = file.split("/api/")[1] || file;
+        log(`API route updated: ${shortPath}`);
+        for (const mod of modules) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+        let routePathToUpdate = null;
+        for (const [routePath, route] of apiRoutesCache) {
+          if (route.filePath === file) {
+            routePathToUpdate = routePath;
+            break;
+          }
+        }
+        if (routePathToUpdate) {
+          try {
+            const routeModule = await server.ssrLoadModule(file);
+            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) {
+              apiRoutesCache.set(routePathToUpdate, {
+                path: routePathToUpdate,
+                filePath: file,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`API route reloaded: ${routePathToUpdate}`);
+              await createRouter();
+              log(`API router recreated`);
+            }
+          } catch (e) {
+            log(`API route HMR failed: ${e.message}`);
+          }
+        } else {
+          try {
+            const path = await import("path");
+            const apiDir = path.join(server.config.root, srcDir, "api");
+            const relativePath = path.relative(apiDir, path.dirname(file));
+            const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+            const routeModule = await server.ssrLoadModule(file);
+            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) {
+              apiRoutesCache.set(routePath, {
+                path: routePath,
+                filePath: file,
+                methods: availableMethods,
+                endpoints
+              });
+              log(`New API route discovered: ${routePath}`);
+              await createRouter();
+            }
+          } catch (e) {
+            log(`New API route load failed: ${e.message}`);
+          }
+        }
+        return [];
+      }
+    }
+  };
+}
+__name(farmApiPlugin, "farmApiPlugin");
+
+export {
+  createEndpoint,
+  GET,
+  HEAD,
+  POST,
+  PUT,
+  DELETE,
+  PATCH,
+  OPTIONS,
+  farmApiPlugin
+};
+//# sourceMappingURL=chunk-PRNYWD7K.mjs.map