Support export methods in api route

Author: ije

framework/react/router.ts

@@ -67,7 +67,8 @@ export const Router: FC<RouterProps> = ({ ssrContext, suspense, createPortal })
       if (deployId) {
         url += `?v=${deployId}`;
       }
-      const { default: defaultExport, data: withData } = await import(url);
+      const { default: defaultExport, data, GET } = await import(url);
+      const withData = Boolean(data ?? GET);
       routeModules[filename] = { defaultExport, withData };
       return { defaultExport, withData };
     };

server/build.ts

@@ -93,24 +93,16 @@ export async function build(serverEntry?: string) {
       `;
     }).join("\n"),
     ...routeFiles.map(([filename, exportNames], idx) => {
-      const hasDefaultExport = exportNames.includes("default");
-      const hasDataExport = exportNames.includes("data");
-      if (!hasDefaultExport && !hasDataExport) {
+      if (exportNames.length === 0) {
         return [];
       }
       const url = `http://localhost:${modulesProxyPort}${filename.slice(1)}`;
       return [
-        `import { ${
-          [
-            hasDefaultExport && `default as $${idx}`,
-            hasDataExport && `data as $$${idx}`,
-          ].filter(Boolean).join(", ")
-        } } from ${JSON.stringify(url)};`,
+        `import { ${exportNames.map((name) => `${name} as ${"$".repeat(idx + 1)}${idx}`).join(", ")} } from ${
+          JSON.stringify(url)
+        };`,
         `revive(${JSON.stringify(filename)}, { ${
-          [
-            hasDefaultExport && `default: $${idx}`,
-            hasDataExport && `data: $$${idx}`,
-          ].filter(Boolean).join(", ")
+          exportNames.map((name) => `${name}: ${"$".repeat(idx + 1)}${idx}`).join(", ")
         } });`,
       ];
     }),

server/generate.ts

@@ -3,33 +3,31 @@ import type { Route } from "../framework/core/route.ts";
 
 /** generate the `routes.gen.ts` follow the routes config */
 export async function generate(routes: Route[]) {
-  const routeFiles = await Promise.all(routes.map(async ([_, { filename }]) => {
-    const code = await Deno.readTextFile(filename);
-    const exportNames = await parseExportNames(filename, code);
-    return [filename, exportNames];
-  }));
+  const routeFiles: [fiilename: string, exportNames: string[]][] = await Promise.all(
+    routes.map(async ([_, { filename }]) => {
+      const code = await Deno.readTextFile(filename);
+      const exportNames = await parseExportNames(filename, code);
+      return [filename, exportNames];
+    }),
+  );
 
   const imports: string[] = [];
   const revives: string[] = [];
 
   routeFiles.forEach(([filename, exportNames], idx) => {
-    const hasDefaultExport = exportNames.includes("default");
-    const hasDataExport = exportNames.includes("data");
-    if (!hasDefaultExport && !hasDataExport) {
+    if (exportNames.length === 0) {
       return [];
     }
-    imports.push(`import { ${
-      [
-        hasDefaultExport && `default as $${idx}`,
-        hasDataExport && `data as $$${idx}`,
-      ].filter(Boolean).join(", ")
-    } } from ${JSON.stringify(filename)};`);
-    revives.push(`revive(${JSON.stringify(filename)}, { ${
-      [
-        hasDefaultExport && `default: $${idx}`,
-        hasDataExport && `data: $$${idx}`,
-      ].filter(Boolean).join(", ")
-    } });`);
+    imports.push(
+      `import { ${exportNames.map((name) => `${name} as ${"$".repeat(idx + 1)}${idx}`).join(", ")} } from ${
+        JSON.stringify(filename)
+      };`,
+    );
+    revives.push(
+      `revive(${JSON.stringify(filename)}, { ${
+        exportNames.map((name) => `${name}: ${"$".repeat(idx + 1)}${idx}`).join(", ")
+      } });`,
+    );
   });
 
   if (imports.length) {

server/mod.ts

@@ -271,18 +271,19 @@ export const serve = (options: ServerOptions = {}) => {
         const fromFetchApi = accept === "application/json" || !accept?.includes("html");
         if (ret) {
           try {
+            const { method } = req;
             const mod = await importRouteModule(filename);
-            const dataConfig: Record<string, unknown> = util.isPlainObject(mod.data) ? mod.data : {};
-            if (req.method !== "GET" || mod.default === undefined || fromFetchApi) {
+            const dataConfig = util.isPlainObject(mod.data) ? mod.data : mod;
+            if (method !== "GET" || mod.default === undefined || fromFetchApi) {
               Object.assign(ctx.params, ret.pathname.groups);
-              const anyFetcher = dataConfig.any;
+              const anyFetcher = dataConfig.any ?? dataConfig.ANY;
               if (typeof anyFetcher === "function") {
                 const res = await anyFetcher(req, ctx);
                 if (res instanceof Response) {
                   return res;
                 }
               }
-              const fetcher = dataConfig[req.method.toLowerCase()];
+              const fetcher = dataConfig[method.toLowerCase()] ?? dataConfig[method];
               if (typeof fetcher === "function") {
                 const res = await fetcher(req, ctx);
                 if (res instanceof Response) {

server/renderer.ts

@@ -130,17 +130,16 @@ export default {
             }
           }
         }
-        const ttls = routeModules.filter(({ dataCacheTtl }) =>
-          typeof dataCacheTtl === "number" && !Number.isNaN(dataCacheTtl) && dataCacheTtl > 0
-        ).map(({ dataCacheTtl }) => Number(dataCacheTtl));
-        if (ttls.length > 1) {
+        if (
+          routeModules.every(({ dataCacheTtl: ttl }) => typeof ttl === "number" && !Number.isNaN(ttl) && ttl > 0)
+        ) {
+          const ttls = routeModules.map(({ dataCacheTtl }) => Number(dataCacheTtl));
           headers.append("Cache-Control", `${cc}, max-age=${Math.min(...ttls)}`);
-        } else if (ttls.length == 1) {
-          headers.append("Cache-Control", `${cc}, max-age=${ttls[0]}`);
         } else {
           headers.append("Cache-Control", `${cc}, max-age=0, must-revalidate`);
         }
         if (csp) {
+          // todo: parse nonce
           headers.append("Content-Security-Policy", [csp].flat().join("; "));
         }
         ssrRes = {
@@ -354,7 +353,7 @@ async function initSSR(
   // import module and fetch data for each matched route
   const modules = await Promise.all(matches.map(async ([ret, { filename }]) => {
     const mod = await importRouteModule(filename);
-    const dataConfig: Record<string, unknown> = util.isPlainObject(mod.data) ? mod.data : {};
+    const dataConfig = util.isPlainObject(mod.data) ? mod.data : mod;
     const rmod: RouteModule = {
       url: new URL(ret.pathname.input + url.search, url.href),
       params: ret.pathname.groups,
@@ -366,19 +365,19 @@ async function initSSR(
     // assign route params to context
     Object.assign(ctx.params, ret.pathname.groups);
 
-    // check `any` fetch of data, throw if it returns a response object
-    const anyFetcher = dataConfig.any;
-    if (typeof anyFetcher === "function") {
-      const res = await anyFetcher(req, ctx);
-      if (res instanceof Response) {
-        throw res;
-      }
-    }
-
-    // check `get` of data, if `suspense` is enabled then return a promise instead
-    const fetcher = dataConfig.get;
+    // check the `get` method of data, if `suspense` is enabled then return a promise instead
+    const fetcher = dataConfig.get ?? dataConfig.GET;
     if (typeof fetcher === "function") {
       const fetchData = async () => {
+        // check the `any` method of data, throw the response object if it returns one
+        const anyFetcher = dataConfig.any ?? dataConfig.ANY;
+        if (typeof anyFetcher === "function") {
+          const res = await anyFetcher(req, ctx);
+          if (res instanceof Response) {
+            throw res;
+          }
+        }
+
         let res: unknown;
         try {
           res = fetcher(req, ctx);