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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farm.js/plugin",
-  "version": "0.1.0-beta.0",
+  "version": "0.1.0-beta.10",
   "description": "Official plugins for Farm.js framework",
   "license": "MIT",
   "author": "Farm.js Team",
@@ -61,28 +61,35 @@
     "nitro": "3.0.1-alpha.0",
     "picocolors": "^1.0.0",
     "rsc-html-stream": "^0.0.4",
-    "@farm.js/core": "0.1.0-beta.0"
+    "@farm.js/core": "0.1.0-beta.10"
   },
   "devDependencies": {
     "@types/node": "^20.19.21",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
-    "@vitejs/plugin-rsc": "^0.5.18",
+    "@vitejs/plugin-rsc": "0.5.32",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "react-server-dom-webpack": "19.2.8",
     "tsdown": "^0.15.7",
     "typescript": "^5.5.3",
     "vite": "^6.0.0",
     "vitest": "^1.1.0"
   },
   "peerDependencies": {
-    "@vitejs/plugin-rsc": ">=0.5.0",
-    "react": ">=19.0.0",
-    "react-dom": ">=19.0.0",
+    "@vitejs/plugin-rsc": "0.5.32",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "react-server-dom-webpack": "19.2.8",
     "vite": ">=6.0.0",
-    "@farm.js/core": "0.1.0-beta.0"
+    "@farm.js/core": "0.1.0-beta.10"
   },
   "peerDependenciesMeta": {
     "@vitejs/plugin-rsc": {
       "optional": true
+    },
+    "react-server-dom-webpack": {
+      "optional": true
     }
   },
   "scripts": {

package/dist/api/index.d.ts

@@ -1,42 +0,0 @@
-/**
- * Farm.js API Routes Plugin
- *
- * Standalone API route support that works with or without RSC.
- *
- * Supports two patterns:
- * 1. File-based routing: /src/api/hello/route.ts -> /api/hello
- *    The path is auto-inferred from file location
- *
- * 2. Root routes.ts file: /src/routes.ts with explicit paths
- *    createEndpoint('/api/custom', { method: 'GET' }, handler)
- *
- * Uses better-call's createRouter for proper Zod validation and parsing.
- *
- * @example
- * ```ts
- * import { farmApi } from '@farm.js/plugin/api'
- *
- * export default defineConfig({
- *   plugins: [farmApi({ srcDir: 'src' })],
- * })
- * ```
- */
-import type { Plugin } from "vite";
-export interface FarmApiOptions {
-    /** Source directory containing the api folder (default: 'src') */
-    srcDir?: string;
-    /** Enable debug logging */
-    debug?: boolean;
-}
-export interface ApiRoute {
-    path: string;
-    filePath: string;
-    methods: string[];
-    endpoints: Record<string, any>;
-}
-/**
- * Farm.js API Routes Plugin
- */
-export default function farmApi(options?: FarmApiOptions): Plugin;
-export { farmApi };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAGlD,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CAgmBpE;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/api/index.js

@@ -1,567 +0,0 @@
-/**
- * Farm.js API Routes Plugin
- *
- * Standalone API route support that works with or without RSC.
- *
- * Supports two patterns:
- * 1. File-based routing: /src/api/hello/route.ts -> /api/hello
- *    The path is auto-inferred from file location
- *
- * 2. Root routes.ts file: /src/routes.ts with explicit paths
- *    createEndpoint('/api/custom', { method: 'GET' }, handler)
- *
- * Uses better-call's createRouter for proper Zod validation and parsing.
- *
- * @example
- * ```ts
- * import { farmApi } from '@farm.js/plugin/api'
- *
- * export default defineConfig({
- *   plugins: [farmApi({ srcDir: 'src' })],
- * })
- * ```
- */
-import { _withAfterNodeMiddleware } from "@farm.js/core/after";
-/**
- * Farm.js API Routes Plugin
- */
-export default function farmApi(options = {}) {
-    const srcDir = options.srcDir ?? "src";
-    const debug = options.debug ?? false;
-    // API routes cache
-    let apiRoutesCache = new Map();
-    let apiRouterHandler = null;
-    let discoveryComplete = false;
-    let discoveryPromise = null;
-    let currentServer = null;
-    // Debug-only logging for discovery messages with [FARM] prefix
-    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}`);
-        }
-    };
-    // Always log API request/response with [FARM] [API] [METHOD] format
-    const logResponse = (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 log = [
-                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(log);
-        }
-        catch {
-            console.log(`[FARM] [API] [${method}] ${urlPath} - ${status} (${duration}ms)`);
-        }
-    };
-    // Create API router handler
-    // We use direct invocation for better control over path matching
-    const createBetterCallRouter = async () => {
-        const totalEndpoints = Array.from(apiRoutesCache.values()).reduce((sum, route) => sum + route.methods.length, 0);
-        if (totalEndpoints > 0) {
-            // Create a handler that matches routes and invokes endpoints
-            apiRouterHandler = async (request) => {
-                const url = new URL(request.url);
-                const method = request.method;
-                const pathname = url.pathname;
-                // Find matching route
-                const route = apiRoutesCache.get(pathname);
-                if (!route) {
-                    return new Response(JSON.stringify({ error: "Not Found" }), {
-                        status: 404,
-                        headers: { "Content-Type": "application/json" },
-                    });
-                }
-                const endpoint = route.endpoints[method];
-                if (!endpoint) {
-                    return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
-                        status: 405,
-                        headers: { "Content-Type": "application/json" },
-                    });
-                }
-                try {
-                    // Parse query params
-                    const queryObj = {};
-                    url.searchParams.forEach((value, key) => {
-                        queryObj[key] = value;
-                    });
-                    // Parse body for non-GET requests
-                    let bodyObj = {};
-                    if (method !== "GET" && method !== "HEAD") {
-                        try {
-                            const bodyText = await request.text();
-                            if (bodyText) {
-                                bodyObj = JSON.parse(bodyText);
-                            }
-                        }
-                        catch {
-                            // Body parsing failed, use empty object
-                        }
-                    }
-                    // Parse headers
-                    const headersObj = {};
-                    request.headers.forEach((value, key) => {
-                        headersObj[key] = value;
-                    });
-                    // Validate with Zod if schemas are defined
-                    const types = endpoint.__types || {};
-                    let validatedQuery = queryObj;
-                    let validatedBody = bodyObj;
-                    if (types.query && typeof types.query.parse === "function") {
-                        try {
-                            validatedQuery = types.query.parse(queryObj);
-                        }
-                        catch (e) {
-                            return new Response(JSON.stringify({
-                                error: "Invalid query parameters",
-                                details: e.errors || e.message,
-                            }), {
-                                status: 400,
-                                headers: { "Content-Type": "application/json" },
-                            });
-                        }
-                    }
-                    if (types.body && typeof types.body.parse === "function") {
-                        try {
-                            validatedBody = types.body.parse(bodyObj);
-                        }
-                        catch (e) {
-                            return new Response(JSON.stringify({
-                                error: "Invalid request body",
-                                details: e.errors || e.message,
-                            }), {
-                                status: 400,
-                                headers: { "Content-Type": "application/json" },
-                            });
-                        }
-                    }
-                    // Build context object
-                    const ctx = {
-                        query: validatedQuery,
-                        body: validatedBody,
-                        headers: headersObj,
-                        request,
-                        context: {},
-                        params: {},
-                    };
-                    // Call the handler (use __handler if available, otherwise the endpoint itself)
-                    const handlerFn = endpoint.__handler || endpoint;
-                    const result = await handlerFn(ctx);
-                    // If result is already a Response, return it
-                    if (result instanceof Response) {
-                        return result;
-                    }
-                    // Otherwise, serialize to JSON
-                    return new Response(JSON.stringify(result), {
-                        status: 200,
-                        headers: { "Content-Type": "application/json" },
-                    });
-                }
-                catch (error) {
-                    return new Response(JSON.stringify({ error: error.message || "Internal Server Error" }), {
-                        status: 500,
-                        headers: { "Content-Type": "application/json" },
-                    });
-                }
-            };
-            log(`better-call router created with ${totalEndpoints} endpoints`);
-        }
-    };
-    // Fallback handler when better-call is not available
-    const createFallbackHandler = () => {
-        return async (request) => {
-            const url = new URL(request.url);
-            const method = request.method;
-            // Find matching route
-            const route = apiRoutesCache.get(url.pathname);
-            if (!route) {
-                return new Response(JSON.stringify({ error: "Not Found" }), {
-                    status: 404,
-                    headers: { "Content-Type": "application/json" },
-                });
-            }
-            const endpoint = route.endpoints[method];
-            if (!endpoint) {
-                return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
-                    status: 405,
-                    headers: { "Content-Type": "application/json" },
-                });
-            }
-            try {
-                // For fallback, call the endpoint directly (without Zod parsing)
-                const result = await endpoint(request);
-                if (result instanceof Response) {
-                    return result;
-                }
-                return new Response(JSON.stringify(result), {
-                    status: 200,
-                    headers: { "Content-Type": "application/json" },
-                });
-            }
-            catch (error) {
-                return new Response(JSON.stringify({ error: error.message || "Internal Server Error" }), {
-                    status: 500,
-                    headers: { "Content-Type": "application/json" },
-                });
-            }
-        };
-    };
-    return {
-        name: "@farm.js/plugin/api",
-        enforce: "pre",
-        configureServer(server) {
-            currentServer = server;
-            // Discover API routes
-            const discoverAPIRoutes = async (apiDir) => {
-                const fs = await import("fs");
-                const path = await import("path");
-                if (!fs.existsSync(apiDir)) {
-                    log("No api directory found");
-                    return;
-                }
-                const findRouteFiles = (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;
-                };
-                const routeFiles = findRouteFiles(apiDir);
-                // Clear cache for rediscovery
-                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 methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-                        const endpoints = {};
-                        const availableMethods = [];
-                        for (const method of 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}`);
-                    }
-                }
-                // Router is created after all routes are discovered (including root routes.ts)
-            };
-            // Discover routes from root routes.ts file
-            const discoverRootRoutes = 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);
-                            // Look for exported endpoints with explicit paths
-                            for (const [exportName, exportValue] of Object.entries(routesModule)) {
-                                // Check both object and function exports (better-call returns functions)
-                                const endpoint = exportValue;
-                                if (endpoint && endpoint.__path) {
-                                    const routePath = endpoint.__path;
-                                    const method = endpoint.__method || "GET";
-                                    // Add to cache
-                                    const existing = apiRoutesCache.get(routePath);
-                                    if (existing) {
-                                        existing.methods.push(method);
-                                        existing.endpoints[method] = endpoint;
-                                    }
-                                    else {
-                                        apiRoutesCache.set(routePath, {
-                                            path: routePath,
-                                            filePath: routesFile,
-                                            methods: [method],
-                                            endpoints: { [method]: endpoint },
-                                        });
-                                    }
-                                    // Root route discovery log omitted
-                                }
-                            }
-                        }
-                        catch (e) {
-                            log(`Root routes.ts load failed: ${e.message}`);
-                        }
-                        break; // Only load the first routes file found
-                    }
-                }
-            };
-            // Initialize discovery
-            const initializeDiscovery = async () => {
-                const path = await import("path");
-                const apiDir = path.join(server.config.root, srcDir, "api");
-                await discoverAPIRoutes(apiDir);
-                await discoverRootRoutes();
-                await createBetterCallRouter();
-                discoveryComplete = true;
-            };
-            discoveryPromise = initializeDiscovery().catch((e) => {
-                console.error("[FARM] API discovery error:", e);
-            });
-            // Expose API router for other plugins
-            server.__farmApi__ = {
-                getHandler: () => apiRouterHandler,
-                getRoutes: () => apiRoutesCache,
-                isReady: () => discoveryComplete,
-                waitForDiscovery: () => discoveryPromise,
-            };
-            // Add middleware to handle API requests
-            return () => {
-                server.middlewares.use(_withAfterNodeMiddleware(async (req, res, next) => {
-                    const url = req.url || "/";
-                    const pathname = url.split("?")[0];
-                    const method = req.method || "GET";
-                    // Only handle /api/ routes
-                    if (!pathname.startsWith("/api/")) {
-                        return next();
-                    }
-                    // Wait for discovery
-                    if (discoveryPromise && !discoveryComplete) {
-                        await discoveryPromise;
-                    }
-                    if (!apiRouterHandler) {
-                        return next();
-                    }
-                    const startTime = Date.now();
-                    try {
-                        // Execute middleware if available
-                        const farmMiddleware = server.__farmMiddleware__;
-                        if (farmMiddleware) {
-                            await farmMiddleware.waitForDiscovery?.();
-                            const middlewareData = new Map();
-                            const handled = await farmMiddleware.execute(req, res, pathname, middlewareData);
-                            if (handled) {
-                                const duration = Date.now() - startTime;
-                                logResponse(method, pathname, res.statusCode || 200, duration);
-                                return;
-                            }
-                        }
-                        // Convert Node request to Web Request
-                        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);
-                            }
-                        }
-                        // Get body for non-GET requests
-                        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 || undefined,
-                        });
-                        const response = await apiRouterHandler(request);
-                        const duration = Date.now() - startTime;
-                        logResponse(method, pathname, response.status, duration);
-                        // Send response
-                        res.statusCode = response.status;
-                        response.headers.forEach((value, key) => {
-                            res.setHeader(key, value);
-                        });
-                        const responseBody = await response.text();
-                        res.end(responseBody);
-                    }
-                    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() || "";
-            // Handle root routes.ts updates
-            if (fileName === "routes.ts" || fileName === "routes.tsx" || fileName === "routes.js") {
-                log(`Root routes file updated: ${fileName}`);
-                // Invalidate all affected modules
-                for (const mod of modules) {
-                    server.moduleGraph.invalidateModule(mod);
-                }
-                // Clear routes that came from this file and rediscover
-                for (const [routePath, route] of apiRoutesCache) {
-                    if (route.filePath === file) {
-                        apiRoutesCache.delete(routePath);
-                    }
-                }
-                try {
-                    const routesModule = await server.ssrLoadModule(file);
-                    // Look for exported endpoints with explicit paths
-                    // Endpoints can be functions (from better-call) or objects
-                    for (const [exportName, exportValue] of Object.entries(routesModule)) {
-                        const endpoint = exportValue;
-                        if (endpoint && endpoint.__path) {
-                            const routePath = endpoint.__path;
-                            const method = endpoint.__method || "GET";
-                            // Add to cache
-                            const existing = apiRoutesCache.get(routePath);
-                            if (existing) {
-                                existing.methods.push(method);
-                                existing.endpoints[method] = endpoint;
-                            }
-                            else {
-                                apiRoutesCache.set(routePath, {
-                                    path: routePath,
-                                    filePath: file,
-                                    methods: [method],
-                                    endpoints: { [method]: endpoint },
-                                });
-                            }
-                            log(`Root route reloaded: ${method} ${routePath}`);
-                        }
-                    }
-                    // Recreate better-call router
-                    await createBetterCallRouter();
-                    log(`better-call 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}`);
-                // Invalidate all affected modules
-                for (const mod of modules) {
-                    server.moduleGraph.invalidateModule(mod);
-                }
-                // Find the route path for this file
-                let routePathToUpdate = null;
-                for (const [routePath, route] of apiRoutesCache) {
-                    if (route.filePath === file) {
-                        routePathToUpdate = routePath;
-                        break;
-                    }
-                }
-                if (routePathToUpdate) {
-                    try {
-                        // Reload the module
-                        const routeModule = await server.ssrLoadModule(file);
-                        const methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-                        const endpoints = {};
-                        const availableMethods = [];
-                        for (const method of 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}`);
-                            // Recreate better-call router with updated endpoints
-                            await createBetterCallRouter();
-                            log(`better-call router recreated`);
-                        }
-                    }
-                    catch (e) {
-                        log(`API route HMR failed: ${e.message}`);
-                    }
-                }
-                else {
-                    // New route file - discover it
-                    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 methods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
-                        const endpoints = {};
-                        const availableMethods = [];
-                        for (const method of 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}`);
-                            // Recreate better-call router with new endpoint
-                            await createBetterCallRouter();
-                        }
-                    }
-                    catch (e) {
-                        log(`New API route load failed: ${e.message}`);
-                    }
-                }
-                return [];
-            }
-        },
-    };
-}
-export { farmApi };