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

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @farm.js/plugin - Official plugins for Farm.js framework
+ *
+ * This package provides official plugins that extend Farm.js functionality.
+ *
+ * Available plugins:
+ * - @farm.js/plugin/rsc - React Server Components support
+ * - @farm.js/plugin/middleware - Standalone middleware support
+ * - @farm.js/plugin/api - Standalone API routes support
+ * - @farm.js/plugin/observability - request/render/build observability lifecycle hooks
+ * - @farm.js/plugin/context - example request context exposure plugin
+ *
+ * @example
+ * ```ts
+ * // Using RSC (includes middleware and API support)
+ * import { defineConfig } from '@farm.js/plugin/rsc'
+ *
+ * export default defineConfig({
+ *   srcDir: 'src',
+ *   experimental: {
+ *     serverComponents: true,
+ *     serverActions: true,
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using standalone plugins (without RSC)
+ * import { defineConfig } from 'vite'
+ * import { farmMiddleware } from '@farm.js/plugin/middleware'
+ * import { farmApi } from '@farm.js/plugin/api'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     farmMiddleware({ srcDir: 'src', debug: true }),
+ *     farmApi({ srcDir: 'src', debug: true }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const version = "0.1.0-beta.12";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,eAAO,MAAM,OAAO,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,49 @@
+/**
+ * @farm.js/plugin - Official plugins for Farm.js framework
+ *
+ * This package provides official plugins that extend Farm.js functionality.
+ *
+ * Available plugins:
+ * - @farm.js/plugin/rsc - React Server Components support
+ * - @farm.js/plugin/middleware - Standalone middleware support
+ * - @farm.js/plugin/api - Standalone API routes support
+ * - @farm.js/plugin/observability - request/render/build observability lifecycle hooks
+ * - @farm.js/plugin/context - example request context exposure plugin
+ *
+ * @example
+ * ```ts
+ * // Using RSC (includes middleware and API support)
+ * import { defineConfig } from '@farm.js/plugin/rsc'
+ *
+ * export default defineConfig({
+ *   srcDir: 'src',
+ *   experimental: {
+ *     serverComponents: true,
+ *     serverActions: true,
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using standalone plugins (without RSC)
+ * import { defineConfig } from 'vite'
+ * import { farmMiddleware } from '@farm.js/plugin/middleware'
+ * import { farmApi } from '@farm.js/plugin/api'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     farmMiddleware({ srcDir: 'src', debug: true }),
+ *     farmApi({ srcDir: 'src', debug: true }),
+ *   ],
+ * })
+ * ```
+ */
+export const version = "0.1.0-beta.12";
+// Note: Import plugins from their respective subpaths:
+// - @farm.js/plugin/rsc
+// - @farm.js/plugin/middleware
+// - @farm.js/plugin/api
+// - @farm.js/plugin/observability
+// - @farm.js/plugin/context
+// This avoids bundling unused code

package/dist/middleware/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 type { Plugin, ViteDevServer } from "vite";
+import type { IncomingMessage, ServerResponse } from "http";
+export interface FarmMiddlewareOptions {
+    /** Source directory containing middleware files (default: 'src') */
+    srcDir?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Cookie options
+ */
+export interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "strict" | "lax" | "none";
+}
+/**
+ * Cookie management interface
+ */
+export interface CookieJar {
+    get(name: string): string | undefined;
+    set(name: string, value: string, options?: CookieOptions): void;
+    delete(name: string): void;
+    getAll(): Record<string, string>;
+}
+/**
+ * Full middleware context - compatible with @farm.js/core/middleware
+ */
+export interface MiddlewareContext {
+    request: IncomingMessage;
+    response: ServerResponse;
+    url: URL;
+    pathname: string;
+    searchParams: URLSearchParams;
+    method: string;
+    params: Record<string, string>;
+    route: string;
+    parent?: {
+        data: Map<string, any>;
+        headers: Record<string, string>;
+    };
+    vite: {
+        isDev: boolean;
+        hmr: boolean;
+        server?: ViteDevServer;
+    };
+    data: Map<string, any>;
+    headers: Map<string, string>;
+    cookies: CookieJar;
+    _handled: boolean;
+    _redirectUrl?: string;
+    _rewriteUrl?: string;
+    redirect(url: string, status?: number): void;
+    rewrite(url: string): void;
+    json(data: any, status?: number): void;
+    text(content: string, status?: number): void;
+    html(content: string, status?: number): void;
+}
+export type MiddlewareHandler = (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void> | void;
+export interface DiscoveredMiddleware {
+    path: string;
+    filePath: string;
+    module: MiddlewareHandler | {
+        build: () => {
+            handlers: MiddlewareHandler[];
+        };
+        setBasePath?: (path: string) => void;
+    };
+    config?: {
+        matcher?: string[];
+    };
+}
+/**
+ * Farm.js Middleware Plugin
+ */
+export default function farmMiddleware(options?: FarmMiddlewareOptions): Plugin;
+export { farmMiddleware };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/middleware/index.ts"],"names":[],"mappings":"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"}

package/dist/middleware/index.js

@@ -0,0 +1,469 @@
+/**
+ * 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";
+// 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,
+    };
+};
+/**
+ * Parse cookies from Cookie header
+ */
+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()] = decodeURIComponent(value);
+        }
+        return cookies;
+    }, {});
+}
+/**
+ * Serialize a cookie
+ */
+function serializeCookie(name, value, options = {}) {
+    let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+    if (options.maxAge) {
+        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;
+}
+/**
+ * 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;
+    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;
+            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;
+            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;
+            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;
+            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) => {
+                    if (mw.path === "/")
+                        return true;
+                    return pathname.startsWith(mw.path) || 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
+                    if (pathname.startsWith("/@") ||
+                        pathname.startsWith("/__") ||
+                        pathname.startsWith("/node_modules") ||
+                        (pathname.includes(".") && !pathname.endsWith("/"))) {
+                        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 };