fix: use static params in file-system based router for ssg (#83)

Implements static parameters support in the file-system based router and
validates input parameters for static routes at static-site generation
phase of an application build. Converts static parameters defined in a
`.static.{ts,mjs,json}` to SSG compatible format.

Static parameters exported as default:

```ts
// /posts/[id].static.ts
export default [{ id: 1 }, { id: 2 }, { id: 3 }]
```

Converted to the default format used in `exports` of configuration in a
`react-server.config.mjs`:

```js
[{ path: "/posts/1" }, { path: "/posts/2" }, { path: "/posts/3" }]
```

#81

Author: lazarv

packages/react-server/lib/build/static.mjs

@@ -107,7 +107,16 @@ export default async function staticSiteGenerator(root, options) {
       paths =
         typeof configRoot.export === "function"
           ? await configRoot.export(paths)
-          : [...configRoot.export, ...paths];
+          : [...(configRoot.export ?? []), ...paths];
+      const validPaths = paths.filter(({ path, filename }) => filename || path);
+      if (validPaths.length < paths.length) {
+        throw new Error(
+          `${colors.bold("path")} property is not defined for ${colors.bold(
+            paths.length - validPaths.length
+          )} path${paths.length - validPaths.length > 1 ? "s" : ""}`
+        );
+      }
+      paths = validPaths;
 
       if (paths.length === 0) {
         console.log(colors.yellow("warning: no paths to export, skipping..."));

packages/react-server/lib/plugins/file-router/plugin.mjs

@@ -9,6 +9,7 @@ import { forChild, forRoot } from "@lazarv/react-server/config/context.mjs";
 import * as sys from "@lazarv/react-server/lib/sys.mjs";
 import merge from "@lazarv/react-server/lib/utils/merge.mjs";
 import { getContext } from "@lazarv/react-server/server/context.mjs";
+import { applyParamsToPath } from "@lazarv/react-server/server/route-match.mjs";
 import { BUILD_OPTIONS } from "@lazarv/react-server/server/symbols.mjs";
 import { watch } from "chokidar";
 import glob from "fast-glob";
@@ -749,46 +750,62 @@ export default function viteReactServerRouter(options = {}) {
           for (const [, path] of manifest.pages.filter(
             ([, , outlet, type]) => !outlet && type === "page"
           )) {
-            if (/\[[^/]+\]/.test(path)) {
-              try {
-                const staticSrc = manifest.pages.find(
-                  ([, staticPath, , staticType]) =>
-                    staticType === "static" && staticPath === path
-                )?.[0];
-
-                if (staticSrc) {
-                  const key = relative(cwd, dirname(staticSrc));
-                  const filename = basename(staticSrc);
-                  const src = join(cwd, key, filename);
-                  const hash = createHash("shake256", {
-                    outputLength: 4,
-                  })
-                    .update(await readFile(src, "utf8"))
-                    .digest("hex");
-                  const exportEntry = pathToFileURL(
-                    join(cwd, outDir, "static", `${hash}.mjs`)
-                  );
-                  config.build.rollupOptions.input[join("static", hash)] =
-                    staticSrc;
-                  paths.push(async () => {
-                    const staticPaths = (await import(exportEntry)).default;
-                    if (typeof staticPaths === "boolean" && staticPaths) {
-                      if (/\[[^\]]+\]/.test(path)) {
-                        throw new Error(
-                          `Static path ${colors.green(path)} contains dynamic segments`
-                        );
-                      }
-                      return path;
-                    }
-                    if (typeof staticPaths === "function") {
-                      return await staticPaths();
+            try {
+              const staticSrc = manifest.pages.find(
+                ([, staticPath, , staticType]) =>
+                  staticType === "static" && staticPath === path
+              )?.[0];
+
+              if (staticSrc) {
+                const key = relative(cwd, dirname(staticSrc));
+                const filename = basename(staticSrc);
+                const src = join(cwd, key, filename);
+                const hash = createHash("shake256", {
+                  outputLength: 4,
+                })
+                  .update(await readFile(src, "utf8"))
+                  .digest("hex");
+                const exportEntry = pathToFileURL(
+                  join(cwd, outDir, "static", `${hash}.mjs`)
+                );
+                config.build.rollupOptions.input[join("static", hash)] =
+                  staticSrc;
+                paths.push(async () => {
+                  const staticPaths = (await import(exportEntry)).default;
+                  if (typeof staticPaths === "boolean" && staticPaths) {
+                    if (/\[[^\]]+\]/.test(path)) {
+                      throw new Error(
+                        `missing values on static site generation of ${colors.bold(
+                          path
+                        )}, add missing values for all dynamic segments`
+                      );
                     }
-                    return staticPaths;
-                  });
-                }
-              } catch (e) {
-                console.error(e);
+                    return { path };
+                  }
+                  if (typeof staticPaths === "function") {
+                    return await staticPaths();
+                  }
+                  const validPaths = await Promise.all(
+                    staticPaths.map(async (def) => {
+                      let obj = def;
+                      if (typeof def === "function") {
+                        obj = await def();
+                      }
+                      try {
+                        return { path: applyParamsToPath(path, obj) };
+                      } catch (e) {
+                        if (typeof obj.path === "string") {
+                          return { path: obj.path };
+                        }
+                        throw e;
+                      }
+                    })
+                  );
+                  return validPaths;
+                });
               }
+            } catch (e) {
+              console.error(e);
             }
           }
           if (paths.length > 0) {