@farm.js/plugin 0.1.0-beta.10 → 0.1.0-beta.100

package/dist/middleware/index.js

@@ -0,0 +1,444 @@
+/**
+ * Farm.js Middleware Plugin
+ *
+ * Standalone middleware support that works with or without RSC.
+ * Discovers and executes middleware.ts files in the source directory.
+ *
+ * @example
+ * ```ts
+ * import { farmMiddleware } from '@farm.js/plugin/middleware'
+ *
+ * export default defineConfig({
+ *   plugins: [farmMiddleware({ srcDir: 'src' })],
+ * })
+ * ```
+ */
+import { createRequire } from "node:module";
+import { _withAfterNodeMiddleware } from "@farm.js/core/after";
+import { devServableFileExists } from "../dev-static.js";
+import { middlewareMatchesPath, parseCookies, serializeCookie } from "./matching.js";
+// Create require for ESM compatibility
+const require_ = createRequire(import.meta.url);
+// Get picocolors with forced color support (to handle NO_COLOR env being set)
+const getColors = () => {
+    try {
+        const pico = require_("picocolors");
+        if (typeof pico?.createColors === "function") {
+            return pico.createColors(true);
+        }
+        if (typeof pico?.green === "function")
+            return pico;
+    }
+    catch { }
+    const id = (s) => s;
+    return {
+        bold: id,
+        dim: id,
+        cyan: id,
+        red: id,
+        yellow: id,
+        blue: id,
+        white: id,
+        gray: id,
+        green: id,
+        magenta: id,
+    };
+};
+/**
+ * Create a cookie jar for managing cookies
+ */
+function createCookieJar(req, res) {
+    const cookies = parseCookies(req.headers.cookie);
+    const setCookies = [];
+    return {
+        get(name) {
+            return cookies[name];
+        },
+        set(name, value, options = {}) {
+            cookies[name] = value;
+            const cookieString = serializeCookie(name, value, options);
+            setCookies.push(cookieString);
+            res.setHeader("Set-Cookie", setCookies);
+        },
+        delete(name) {
+            delete cookies[name];
+            const cookieString = serializeCookie(name, "", {
+                maxAge: 0,
+                expires: new Date(0),
+            });
+            setCookies.push(cookieString);
+            res.setHeader("Set-Cookie", setCookies);
+        },
+        getAll() {
+            return { ...cookies };
+        },
+    };
+}
+/**
+ * Create a full middleware context
+ */
+function createContext(req, res, viteServer) {
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    const headers = new Map();
+    const data = new Map();
+    const cookies = createCookieJar(req, res);
+    let handled = false;
+    // Mirror @farm.js/core's createContext: a header set on ctx.headers in the
+    // same handler that then short-circuits via a helper must still reach the
+    // response. The runner's tail flush is unreachable once a helper sets
+    // _handled, so each helper applies ctx.headers to res before its writeHead.
+    const applyResponseHeaders = () => {
+        for (const [key, value] of headers) {
+            try {
+                res.setHeader(key, value);
+            }
+            catch {
+                // An invalid optional header must not prevent the response itself
+                // from completing.
+            }
+        }
+    };
+    const ctx = {
+        request: req,
+        response: res,
+        url,
+        pathname: url.pathname,
+        searchParams: url.searchParams,
+        method: req.method || "GET",
+        params: {},
+        route: url.pathname,
+        vite: {
+            isDev: process.env.NODE_ENV !== "production",
+            hmr: !!viteServer?.hot,
+            server: viteServer,
+        },
+        data,
+        headers,
+        cookies,
+        _handled: false,
+        redirect(redirectUrl, status = 307) {
+            if (handled) {
+                console.warn("Response already sent, cannot redirect");
+                return;
+            }
+            ctx._redirectUrl = redirectUrl;
+            ctx._handled = true;
+            handled = true;
+            applyResponseHeaders();
+            res.writeHead(status, {
+                Location: redirectUrl,
+                "Content-Type": "text/plain",
+            });
+            res.end(`Redirecting to ${redirectUrl}`);
+        },
+        rewrite(rewriteUrl) {
+            ctx._rewriteUrl = rewriteUrl;
+            // Update the URL for downstream middleware
+            const newUrl = new URL(rewriteUrl, `http://${req.headers.host || "localhost"}`);
+            ctx.url = newUrl;
+            ctx.pathname = newUrl.pathname;
+            ctx.searchParams = newUrl.searchParams;
+            // Update the original request URL
+            req.url = rewriteUrl;
+        },
+        json(jsonData, status = 200) {
+            if (handled) {
+                console.warn("Response already sent, cannot send JSON");
+                return;
+            }
+            ctx._handled = true;
+            handled = true;
+            applyResponseHeaders();
+            res.writeHead(status, {
+                "Content-Type": "application/json",
+            });
+            res.end(JSON.stringify(jsonData));
+        },
+        text(content, status = 200) {
+            if (handled) {
+                console.warn("Response already sent, cannot send text");
+                return;
+            }
+            ctx._handled = true;
+            handled = true;
+            applyResponseHeaders();
+            res.writeHead(status, {
+                "Content-Type": "text/plain",
+            });
+            res.end(content);
+        },
+        html(content, status = 200) {
+            if (handled) {
+                console.warn("Response already sent, cannot send HTML");
+                return;
+            }
+            ctx._handled = true;
+            handled = true;
+            applyResponseHeaders();
+            res.writeHead(status, {
+                "Content-Type": "text/html",
+            });
+            res.end(content);
+        },
+    };
+    return ctx;
+}
+/**
+ * Farm.js Middleware Plugin
+ */
+export default function farmMiddleware(options = {}) {
+    const srcDir = options.srcDir ?? "src";
+    const debug = options.debug ?? false;
+    // Middleware cache
+    let middlewareCache = new Map();
+    let discoveryComplete = false;
+    let discoveryPromise = null;
+    const log = (message) => {
+        if (!debug)
+            return;
+        try {
+            const pc = require("picocolors");
+            console.log(pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]") + " " + pc.gray(message));
+        }
+        catch {
+            console.log(`[FARM] ${message}`);
+        }
+    };
+    return {
+        name: "@farm.js/plugin/middleware",
+        enforce: "pre",
+        configureServer(server) {
+            // Discover middleware
+            const discoverMiddleware = async (dir, routePath = "/") => {
+                const fs = await import("fs");
+                const path = await import("path");
+                if (!fs.existsSync(dir))
+                    return;
+                // Check for middleware file
+                const extensions = [".ts", ".tsx", ".js", ".jsx"];
+                for (const ext of extensions) {
+                    const middlewareFile = path.join(dir, `middleware${ext}`);
+                    if (fs.existsSync(middlewareFile)) {
+                        try {
+                            const module = await server.ssrLoadModule(middlewareFile);
+                            if (module.default) {
+                                middlewareCache.set(routePath, {
+                                    path: routePath,
+                                    filePath: middlewareFile,
+                                    module: module.default,
+                                    config: module.config,
+                                });
+                                log(`Middleware discovered: ${routePath}`);
+                            }
+                        }
+                        catch (e) {
+                            log(`Middleware load failed at ${routePath}: ${e.message}`);
+                        }
+                        break;
+                    }
+                }
+                // Recursively check subdirectories
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory() &&
+                        !entry.name.startsWith(".") &&
+                        !entry.name.startsWith("_") &&
+                        entry.name !== "api") {
+                        const subDir = path.join(dir, entry.name);
+                        const subRoutePath = routePath === "/" ? `/${entry.name}` : `${routePath}/${entry.name}`;
+                        await discoverMiddleware(subDir, subRoutePath);
+                    }
+                }
+            };
+            // Initialize discovery
+            const initializeDiscovery = async () => {
+                const path = await import("path");
+                const appDir = path.join(server.config.root, srcDir);
+                await discoverMiddleware(appDir);
+                discoveryComplete = true;
+            };
+            discoveryPromise = initializeDiscovery().catch((e) => {
+                console.error("[FARM] Middleware discovery error:", e);
+            });
+            // Execute middleware chain
+            const executeMiddleware = async (req, res, pathname, sharedData) => {
+                // Wait for discovery
+                if (discoveryPromise && !discoveryComplete) {
+                    await discoveryPromise;
+                }
+                // Find applicable middleware (cascading from root to specific)
+                const applicable = Array.from(middlewareCache.values())
+                    .filter((mw) => middlewareMatchesPath(pathname, mw.path))
+                    .sort((a, b) => a.path.split("/").length - b.path.split("/").length);
+                if (applicable.length === 0)
+                    return false;
+                const startTime = Date.now();
+                const method = req.method || "GET";
+                // Log middleware execution in the same format as @farm.js/core
+                const pc = getColors();
+                const logMsg = [
+                    pc.dim("[") + pc.bold(pc.blue("FARM")) + pc.dim("]"),
+                    pc.dim("[") + pc.bold(pc.magenta("MIDDLEWARE")) + pc.dim("]"),
+                    pc.dim("[") + pc.bold(pc.white(method.padEnd(3))) + pc.dim("]"),
+                    pc.gray("Executing middleware: "),
+                    pc.gray(pathname),
+                    pc.dim(` (${applicable.length} middleware)`),
+                ].join(" ");
+                console.log(logMsg);
+                // Create full middleware context
+                const ctx = createContext(req, res, server);
+                // Use shared data if provided
+                if (sharedData) {
+                    for (const [key, value] of sharedData) {
+                        ctx.data.set(key, value);
+                    }
+                }
+                for (const mw of applicable) {
+                    const middleware = mw.module;
+                    // Handle middleware chain object (has .build method)
+                    if (middleware && typeof middleware === "object" && "build" in middleware) {
+                        if (typeof middleware.setBasePath === "function") {
+                            middleware.setBasePath(mw.path);
+                        }
+                        const built = middleware.build();
+                        const handlers = built.handlers || [];
+                        let handlerIndex = 0;
+                        const executeNext = async () => {
+                            if (handlerIndex < handlers.length) {
+                                const handler = handlers[handlerIndex++];
+                                await handler(ctx, executeNext);
+                            }
+                        };
+                        await executeNext();
+                    }
+                    else if (typeof middleware === "function") {
+                        // Plain middleware function
+                        await middleware(ctx, async () => { });
+                    }
+                    // Check if response was sent
+                    if (ctx._handled || res.headersSent || res.writableEnded) {
+                        return true;
+                    }
+                }
+                // Apply collected headers to response
+                for (const [key, value] of ctx.headers) {
+                    try {
+                        res.setHeader(key, value);
+                    }
+                    catch (e) { }
+                }
+                // Store middleware data on request for pages to access
+                req.__FARM_MIDDLEWARE_DATA__ = Object.fromEntries(ctx.data);
+                // Log middleware completion
+                const duration = Date.now() - startTime;
+                const pc2 = getColors();
+                const completeLogMsg = [
+                    pc2.dim("[") + pc2.bold(pc2.blue("FARM")) + pc2.dim("]"),
+                    pc2.dim("[") + pc2.bold(pc2.magenta("MIDDLEWARE")) + pc2.dim("]"),
+                    pc2.dim("[") + pc2.bold(pc2.white(method.padEnd(3))) + pc2.dim("]"),
+                    pc2.gray("Completed"),
+                    pc2.gray(pathname),
+                    pc2.dim(`(${duration}ms)`),
+                ].join(" ");
+                console.log(completeLogMsg);
+                return false;
+            };
+            // Expose middleware execution for other plugins
+            server.__farmMiddleware__ = {
+                execute: executeMiddleware,
+                getCache: () => middlewareCache,
+                isReady: () => discoveryComplete,
+                waitForDiscovery: () => discoveryPromise,
+            };
+            // Add middleware to handle requests
+            return () => {
+                server.middlewares.use(_withAfterNodeMiddleware(async (req, res, next) => {
+                    const url = req.url || "/";
+                    const pathname = url.split("?")[0];
+                    // Skip Vite internal requests and real static assets. Dotted
+                    // paths that don't map to a file on disk are app routes (route
+                    // segments may contain dots) and must still run middleware.
+                    if (pathname.startsWith("/@") ||
+                        pathname.startsWith("/__") ||
+                        pathname.startsWith("/node_modules") ||
+                        (pathname.includes(".") &&
+                            !pathname.endsWith("/") &&
+                            devServableFileExists(pathname, [server.config.publicDir, server.config.root]))) {
+                        return next();
+                    }
+                    try {
+                        // Execute middleware
+                        const middlewareData = new Map();
+                        const handled = await executeMiddleware(req, res, pathname, middlewareData);
+                        if (handled) {
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        console.error("[FARM] Middleware error:", e);
+                    }
+                    next();
+                }));
+            };
+        },
+        async handleHotUpdate({ file, server, modules }) {
+            const fileName = file.split("/").pop() || "";
+            if (fileName.startsWith("middleware.")) {
+                log(`Middleware updated: ${fileName}`);
+                // Invalidate the module in Vite's module graph
+                for (const mod of modules) {
+                    server.moduleGraph.invalidateModule(mod);
+                }
+                // Find and update the cached middleware
+                for (const [routePath, mw] of middlewareCache.entries()) {
+                    if (mw.filePath === file) {
+                        try {
+                            // Reload the module
+                            const module = await server.ssrLoadModule(file);
+                            if (module.default) {
+                                middlewareCache.set(routePath, {
+                                    path: routePath,
+                                    filePath: file,
+                                    module: module.default,
+                                    config: module.config,
+                                });
+                                log(`Middleware reloaded: ${routePath}`);
+                            }
+                        }
+                        catch (e) {
+                            log(`Middleware reload failed: ${e.message}`);
+                        }
+                        break;
+                    }
+                }
+                // Also check if this is a new middleware file not yet in cache
+                if (!Array.from(middlewareCache.values()).some((mw) => mw.filePath === file)) {
+                    try {
+                        const path = await import("path");
+                        const srcPath = path.join(server.config.root, srcDir);
+                        const relativePath = file
+                            .replace(srcPath, "")
+                            .replace(/\/middleware\.(ts|tsx|js|jsx)$/, "");
+                        const routePath = relativePath === "" ? "/" : relativePath;
+                        const module = await server.ssrLoadModule(file);
+                        if (module.default) {
+                            middlewareCache.set(routePath, {
+                                path: routePath,
+                                filePath: file,
+                                module: module.default,
+                                config: module.config,
+                            });
+                            log(`New middleware discovered: ${routePath}`);
+                        }
+                    }
+                    catch (e) {
+                        log(`New middleware load failed: ${e.message}`);
+                    }
+                }
+                server.ws.send({ type: "full-reload", path: "*" });
+                return [];
+            }
+        },
+    };
+}
+export { farmMiddleware };

package/dist/middleware/matching.d.ts

@@ -0,0 +1,29 @@
+import type { CookieOptions } from "./index.js";
+/**
+ * Parse cookies from a Cookie header.
+ *
+ * A single request cookie whose value is not valid UTF-8 percent-encoding
+ * (a latin-1 value from an old link, a crawler, or a bare `%`) must not take
+ * the whole map down: an unguarded `decodeURIComponent` throws `URIError`,
+ * which — because the middleware runner swallows the throw and calls `next()` —
+ * would silently skip every middleware for that request (a dev-time auth
+ * bypass). Decoding falls back to the raw value per entry instead.
+ */
+export declare function parseCookies(cookieHeader?: string): Record<string, string>;
+/**
+ * Whether a middleware registered at `middlewarePath` applies to `pathname`.
+ *
+ * Matching is by path segment, not raw string prefix: middleware at `/admin`
+ * covers `/admin` and everything under `/admin/`, but not sibling routes like
+ * `/administrator` or `/admin-public` that merely share a textual prefix.
+ */
+export declare function middlewareMatchesPath(pathname: string, middlewarePath: string): boolean;
+/**
+ * Serialize a cookie.
+ *
+ * `Max-Age=0` is the canonical immediate-expiry directive, so the attribute is
+ * emitted whenever `maxAge` is provided — a `0` must not be dropped the way a
+ * plain truthiness check would drop it.
+ */
+export declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+//# sourceMappingURL=matching.d.ts.map

package/dist/middleware/matching.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matching.d.ts","sourceRoot":"","sources":["../../src/middleware/matching.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAc1E;AAUD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAIvF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CAkChG"}

package/dist/middleware/matching.js

@@ -0,0 +1,79 @@
+/**
+ * Parse cookies from a Cookie header.
+ *
+ * A single request cookie whose value is not valid UTF-8 percent-encoding
+ * (a latin-1 value from an old link, a crawler, or a bare `%`) must not take
+ * the whole map down: an unguarded `decodeURIComponent` throws `URIError`,
+ * which — because the middleware runner swallows the throw and calls `next()` —
+ * would silently skip every middleware for that request (a dev-time auth
+ * bypass). Decoding falls back to the raw value per entry instead.
+ */
+export function parseCookies(cookieHeader) {
+    if (!cookieHeader)
+        return {};
+    return cookieHeader.split(";").reduce((cookies, cookie) => {
+        const [name, ...rest] = cookie.split("=");
+        const value = rest.join("=").trim();
+        if (name && value) {
+            cookies[name.trim()] = decodeCookieValue(value);
+        }
+        return cookies;
+    }, {});
+}
+function decodeCookieValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Whether a middleware registered at `middlewarePath` applies to `pathname`.
+ *
+ * Matching is by path segment, not raw string prefix: middleware at `/admin`
+ * covers `/admin` and everything under `/admin/`, but not sibling routes like
+ * `/administrator` or `/admin-public` that merely share a textual prefix.
+ */
+export function middlewareMatchesPath(pathname, middlewarePath) {
+    if (middlewarePath === "/")
+        return true;
+    if (pathname === middlewarePath)
+        return true;
+    return pathname.startsWith(`${middlewarePath}/`);
+}
+/**
+ * Serialize a cookie.
+ *
+ * `Max-Age=0` is the canonical immediate-expiry directive, so the attribute is
+ * emitted whenever `maxAge` is provided — a `0` must not be dropped the way a
+ * plain truthiness check would drop it.
+ */
+export function serializeCookie(name, value, options = {}) {
+    let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+    if (options.maxAge != null) {
+        cookie += `; Max-Age=${options.maxAge}`;
+    }
+    if (options.expires) {
+        cookie += `; Expires=${options.expires.toUTCString()}`;
+    }
+    if (options.path) {
+        cookie += `; Path=${options.path}`;
+    }
+    else {
+        cookie += "; Path=/";
+    }
+    if (options.domain) {
+        cookie += `; Domain=${options.domain}`;
+    }
+    if (options.secure) {
+        cookie += "; Secure";
+    }
+    if (options.httpOnly) {
+        cookie += "; HttpOnly";
+    }
+    if (options.sameSite) {
+        cookie += `; SameSite=${options.sameSite.charAt(0).toUpperCase() + options.sameSite.slice(1)}`;
+    }
+    return cookie;
+}