feat: add api route support for vercel environment (#307)

* feat: add build for vercel

* feat: add build api route for vercel

* feat: add e2e tests for vercel api

Author: sirily11

packages/rxbot/src/command/commands/build/build-vercel.ts

@@ -1,10 +1,11 @@
 import { existsSync } from "fs";
 import path from "path";
 import { rspack } from "@rspack/core";
+import { RouteInfo } from "@rx-lab/common";
 import fs from "fs/promises";
 import nunjucks from "nunjucks";
 import {
-  VERCEL_SEND_MESSAGE_TEMPLATE,
+  VERCEL_API_ROUTE_TEMPLATE,
   VERCEL_WEBHOOK_FUNCTION_TEMPLATE,
 } from "../../../templates/vercel";
 
@@ -28,53 +29,74 @@ const VERCEL_CONFIG_FILE_NAME = "config.json";
  * @param content
  */
 async function writeVercelFunctionToDisk(apiRoute: string, content: string) {
-  const functionOutputFolder =
-    path.resolve(VERCEL_FUNCTIONS_FOLDER, apiRoute) + ".func";
+  try {
+    let functionOutputFolder = path.join(
+      path.resolve(VERCEL_FUNCTIONS_FOLDER),
+      apiRoute + ".func",
+    );
 
-  // check if the folder exists
-  if (!existsSync(functionOutputFolder)) {
-    await fs.mkdir(functionOutputFolder, { recursive: true });
-  }
+    // check if the folder exists
+    if (!existsSync(functionOutputFolder)) {
+      await fs.mkdir(functionOutputFolder, { recursive: true });
+    }
 
-  const configFilePath = path.join(
-    functionOutputFolder,
-    VERCEL_FUNCTION_CONFIG_FILENAME,
-  );
+    const configFilePath = path.join(
+      functionOutputFolder,
+      VERCEL_FUNCTION_CONFIG_FILENAME,
+    );
 
-  await build(content, VERCEL_FUNCTION_FILE_NAME, functionOutputFolder);
-  // write config
-  await fs.writeFile(
-    configFilePath,
-    JSON.stringify(
-      {
-        runtime: "nodejs20.x",
-        handler: "index.js",
-        launcherType: "Nodejs",
-        shouldAddHelpers: true,
-      },
-      null,
-      2,
-    ),
-  );
+    await build(content, VERCEL_FUNCTION_FILE_NAME, functionOutputFolder);
+    // write config
+    await fs.writeFile(
+      configFilePath,
+      JSON.stringify(
+        {
+          runtime: "nodejs20.x",
+          handler: "index.js",
+          launcherType: "Nodejs",
+          shouldAddHelpers: true,
+        },
+        null,
+        2,
+      ),
+    );
+  } catch (e) {
+    console.error(e);
+    throw e;
+  }
 }
 
 /**
  * Generate vercel function
  * @param outputDir The generated source code output directory
+ * @param route The route information
  * @param type The type of function to generate
  */
 async function generateVercelFunction(
   outputDir: string,
-  type: "webhook" | "send-message",
+  type: "webhook" | "api",
+  route?: RouteInfo,
 ): Promise<string> {
   switch (type) {
     case "webhook":
       return nunjucks.renderString(VERCEL_WEBHOOK_FUNCTION_TEMPLATE, {
         outputDir,
       });
-    case "send-message":
-      return nunjucks.renderString(VERCEL_SEND_MESSAGE_TEMPLATE, {
+    case "api":
+      // import the api
+      const api = await route?.api!();
+      const supportedMethods = [];
+      for (const method of ["GET", "POST", "PUT", "DELETE", "PATCH"]) {
+        //@ts-expect-error
+        if (api[method]) {
+          supportedMethods.push(method);
+        }
+      }
+
+      return nunjucks.renderString(VERCEL_API_ROUTE_TEMPLATE, {
         outputDir,
+        methods: supportedMethods,
+        path: route!.route,
       });
     default:
       throw new Error(`Unsupported function type: ${type}`);
@@ -174,18 +196,49 @@ async function writeVercelConfigFile() {
   );
 }
 
+/**
+ * Recursively process routes and generate API functions
+ * @param routes Array of route information
+ * @param outputFolder Output folder path
+ */
+async function processRoutes(routes: RouteInfo[], outputFolder: string) {
+  for (const route of routes) {
+    // Generate API function if route has api field
+    if (route.api) {
+      const apiFunction = await generateVercelFunction(
+        outputFolder,
+        "api",
+        route,
+      );
+      await writeVercelFunctionToDisk(route.route, apiFunction);
+    }
+
+    // Recursively process sub-routes if they exist
+    if (route.subRoutes && route.subRoutes.length > 0) {
+      await processRoutes(route.subRoutes, outputFolder);
+    }
+  }
+}
+
 export async function buildVercel({ outputFolder }: Options) {
   await removeVercelFolder();
   // create output folder
   await fs.mkdir(VERCEL_OUTPUT_FOLDER, { recursive: true });
+  // get route file
+  const routeFile = path.resolve(outputFolder, "main.js");
+  // node require
+  const nativeRequire = require("module").createRequire(process.cwd());
+  delete nativeRequire.cache[nativeRequire.resolve(routeFile)];
+  // Now import the fresh version
+  const { ROUTE_FILE } = nativeRequire(routeFile);
+
   // build webhook function
   const webhookFunction = await generateVercelFunction(outputFolder, "webhook");
-  const sendMessageFunction = await generateVercelFunction(
-    outputFolder,
-    "send-message",
-  );
   // write webhook function to disk
   await writeVercelFunctionToDisk("api/webhook", webhookFunction);
-  await writeVercelFunctionToDisk("api/message", sendMessageFunction);
+
+  // Process all routes recursively
+  await processRoutes(ROUTE_FILE.routes, outputFolder);
+
   await writeVercelConfigFile();
 }

packages/rxbot/src/command/commands/build/build.ts

@@ -23,19 +23,22 @@ export default async function runBuild(
   },
 ) {
   Logger.info(
-    `Building the app in $${srcFolder} for ${options.environment} environment`,
+    `Building the app in ${srcFolder} for ${options.environment} environment`,
     "blue",
   );
 
-  Logger.info("Build app completed successfully", "green");
   switch (options.environment) {
     case "vercel":
       Logger.info("Building specifically for Vercel", "blue");
       await buildApp(srcFolder, outputFolder, options.hasAdapterFile ?? true, {
         plugins: [new VercelEnvironmentPlugin()],
       });
       await buildVercel({
-        outputFolder: path.resolve(outputFolder, DEFAULT_OUTPUT_FOLDER),
+        outputFolder: path.resolve(
+          process.cwd(),
+          outputFolder,
+          DEFAULT_OUTPUT_FOLDER,
+        ),
       });
       Logger.info("Build for Vercel completed successfully", "green");
       break;
@@ -44,6 +47,7 @@ export default async function runBuild(
         sourceMap: options.sourceMap,
         plugins: [],
       });
+      Logger.info("Build app completed successfully", "green");
       break;
   }
 }

packages/rxbot/src/command/index.ts

@@ -1,8 +1,9 @@
 import build from "./commands/build/build";
+import runBuild from "./commands/build/build";
 import deploy from "./commands/deploy/deploy";
 import dev from "./commands/dev";
 
 import { Config } from "./commands/deploy/deploy";
 
-export { build, dev, deploy };
+export { build, dev, deploy, runBuild };
 export type { Config };

packages/rxbot/src/templates/vercel/templates.ts

@@ -30,34 +30,36 @@ export async function POST(request: Request) {
 }
 `;
 
-export const VERCEL_SEND_MESSAGE_TEMPLATE = `
+export const VERCEL_API_ROUTE_TEMPLATE = `
 import { Core } from "@rx-lab/core";
 import { adapter, storage, ROUTE_FILE } from "{{outputDir}}/main.js";
 import { waitUntil } from "@vercel/functions";
+import { matchRouteWithPath } from "@rx-lab/router";
 
 global.core = null;
-export async function POST(request: Request) {
-    if (global.core === null) {
-        global.core = await Core.Start({
-            adapter,
-            storage,
-            routeFile: ROUTE_FILE,
-        });
-    }
-    const result = async () => {
-        await global.core.sendMessage(await request.json());
-    }
-    
-    waitUntil(result().catch(console.error));
-    return new Response(
-        JSON.stringify({
-          status: "ok",
-        }),
-        {
-          headers: {
-            "content-type": "application/json",
-          },
-        },
-      );
+{% for method in methods %}
+export async function {{method}}(req: Request) {
+      if (global.core === null) {
+          global.core = await Core.Start({
+              adapter,
+              storage,
+              routeFile: ROUTE_FILE,
+          });
+      }
+      const matchedRoute = await matchRouteWithPath(
+              ROUTE_FILE.routes,
+              "{{path}}"
+            );
+      const api = matchedRoute.api;
+      const handler = api["{{method}}"];
+      const functionRequest = {
+              req,
+              storage: storage,
+              routeInfoFile: ROUTE_FILE,
+              core: global.core,
+            };
+      const resp = await handler(functionRequest);
+      return resp;
 }
+{% endfor %}
 `;