@uniflowed/vite 0.1.0 → 0.2.0

package/driver.js

@@ -256,7 +256,8 @@ async function viteConfig(config, mode) {
     base: basePathOf(config) === "" ? "/" : `${basePathOf(config)}/`,
     clearScreen: false,
     customLogger: eventLogger(argument("--log-level") ?? "info"),
-    plugins: [uniflowed({ root, config, target: routeTarget })],
+    // One `uf transform` for every pass this process runs; see the option.
+    plugins: [uniflowed({ root, config, target: routeTarget, shareTransformAcrossBuilds: true })],
     server: {
       host,
       port,

package/index.js

@@ -46,6 +46,7 @@
 
 import { instrumentationFile } from "./internal/instrumentation.js";
 
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { nativeWebPlugin } from "./internal/native-web.js";
 
@@ -79,6 +80,8 @@ import {
 import {
   RSC_MANIFEST_ENV,
   actionReferenceSource,
+  declaresDefaultExport,
+  serverActionSource,
   actionsModuleSource,
   clientRouteFilter,
   readRscManifest,
@@ -96,7 +99,12 @@ import {
   scanRoutes,
   serverModuleSource,
 } from "./internal/routes.js";
-import { TransformService, isFlowModule, uniflowedPackages } from "@uniflowed/host/transform";
+import {
+  TransformService,
+  isCompiledOutput,
+  isFlowModule,
+  uniflowedPackages,
+} from "@uniflowed/host/transform";
 import {
   DEV_RSC_HOOK,
   FLIGHT_BROWSER_DEPENDENCIES,
@@ -180,6 +188,12 @@ export function devUrlFor(id) {
  * @property {object} [config] the loaded `uf.config.js` object
  * @property {"web" | "native" | "ios" | "android"} [target] app target
  * @property {string} [command] the `uf` binary to transform through
+ * @property {boolean} [shareTransformAcrossBuilds] keep one `uf transform` for
+ *   every build these plugins run, rather than closing it when each ends. For a
+ *   caller that runs several builds with the same plugins and owns the process
+ *   they run in — `driver.js` — which is what makes an idle service left open
+ *   at the end nobody's problem. Off by default: a process that builds many
+ *   projects in turn would otherwise keep one idle `uf` per project.
  */
 
 /**
@@ -252,6 +266,7 @@ export default function uniflowed(options = {}) {
       flightState,
       routing,
       command: options.command,
+      shareTransformAcrossBuilds: options.shareTransformAcrossBuilds === true,
       accessibility,
       relayEnabled: builtins.relay !== false,
     }),
@@ -282,6 +297,7 @@ function flowPlugin({
   flightState,
   routing,
   command,
+  shareTransformAcrossBuilds,
   accessibility,
   relayEnabled,
 }) {
@@ -331,8 +347,11 @@ function flowPlugin({
   /** Findings held back as a dependency's, waiting to be counted out loud. */
   let suppressed = [];
 
+  // A service that has lost its process is replaced rather than kept: under
+  // `shareTransformAcrossBuilds` one outlives a build, and a `uf transform`
+  // that died in one pass must not fail every pass after it.
   const ensureService = () => {
-    service ??= new TransformService({ command, root });
+    if (service == null || !service.alive) service = new TransformService({ command, root });
     return service;
   };
 
@@ -664,6 +683,23 @@ function flowPlugin({
       if (!isSsr(this, loadOptions) && this.environment?.name !== RSC_ENVIRONMENT) {
         const references = actionTables().modules.get(cleanId(id));
         if (references != null) return actionReferenceSource(references);
+        return null;
+      }
+      // And in the server graphs, the file itself behind a module that gives
+      // each callable export what React reads to write a form that posts before
+      // hydration. The file is imported under a query, so it is still one
+      // module; only the plain id is the wrapper. See `serverActionSource`.
+      if (!id.includes("?")) {
+        const exported = actionTables().modules.get(id);
+        if (exported != null) {
+          let source = "";
+          try {
+            source = readFileSync(id, "utf8");
+          } catch {
+            return null;
+          }
+          return serverActionSource(id, exported, declaresDefaultExport(source));
+        }
       }
       return null;
     },
@@ -672,6 +708,10 @@ function flowPlugin({
       // A view of a barrel's namespace has the barrel's path and none of its
       // source: `uf:barrel-imports` generates it as JavaScript.
       if (!isFlowModule(id) || namespaceViewOf(id) != null) return null;
+      // What an earlier pass of this build wrote under `.uf/build/` — the ssr
+      // pass imports the rsc graph's bundle — is already this transform's
+      // output. See `isCompiledOutput`.
+      if (isCompiledOutput(id)) return null;
       // Both server graphs: neither gets a refresh wrapper, and the rsc graph's
       // findings are reported as that graph's.
       const rsc = this.environment?.name === RSC_ENVIRONMENT;
@@ -744,9 +784,15 @@ function flowPlugin({
     buildEnd() {
       summariseSuppressed(this, suppressed);
       suppressed = [];
-      // A dev server keeps its service for the whole session; a build is
-      // done with it here.
-      if (server == null) {
+      // A dev server keeps its service for the whole session. A build is done
+      // with it here, unless the caller runs more builds with these plugins:
+      // `uf build`'s passes — the rsc graph, the client, the server — go over
+      // largely the same modules with the same options, and `uf transform`
+      // answers a request it has already answered from memory. A service per
+      // pass compiled `@uniflowed/router` and every shared module three times.
+      // An idle service does not hold the host open (see `TransformService`),
+      // and its child sees stdin close when the host exits.
+      if (server == null && !shareTransformAcrossBuilds) {
         service?.close();
         service = null;
       }
@@ -1029,7 +1075,34 @@ function flowPlugin({
               // to sit at the URL it was posted to. The same two lines are in
               // `@uniflowed/server`'s `fetch.js`, which is what every
               // deployment runs.
-              const acted = await entry.callAction(asRequest);
+              //
+              // A form posted before its page hydrated is answered with the
+              // page, rendered with the action's result as the submitting
+              // `useActionState`'s state — the render below, given `formState`.
+              const acted = await entry.callAction(asRequest, {
+                postback: async (formState) => {
+                  const result = await entry.render(
+                    url,
+                    { scripts: [devUrlFor(VIRTUAL.client)], styles: [], preloads: [] },
+                    {
+                      onError: (error) => reportRenderError(devServer, url, error),
+                      transformHead: (head) =>
+                        devServer.transformIndexHtml(
+                          url,
+                          flightState == null
+                            ? head
+                            : linkStylesheets(head, devStylesheets(devServer)),
+                        ),
+                      formState,
+                    },
+                  );
+                  if (result.error != null) reportRenderError(devServer, url, result.error);
+                  return new Response(result.stream(), {
+                    status: result.status ?? 200,
+                    headers: { ...result.headers, "content-type": "text/html; charset=utf-8" },
+                  });
+                },
+              });
               if (acted != null) {
                 await send(response, acted);
                 return true;
@@ -1049,10 +1122,16 @@ function flowPlugin({
               if (payloadFor != null && (request.method === "GET" || request.method === "HEAD")) {
                 const query = url.includes("?") ? url.slice(url.indexOf("?")) : "";
                 const target = payloadFor + query;
-                const fromHeader = request.headers[INTERCEPTED_FROM_HEADER];
+                // Read off the request the guard handed back, never off the
+                // one Node received: the middleware runner takes this header
+                // off when the page it names is one the guards of that page
+                // would not serve, and reading the original would render it
+                // anyway. See "A payload that renders over another page" in
+                // `@uniflowed/router/middleware`.
+                const interceptedFrom = asRequest.headers.get(INTERCEPTED_FROM_HEADER) ?? undefined;
                 const answered = await entry.flight(target, {
                   onError: (error) => reportRenderError(devServer, target, error),
-                  interceptedFrom: Array.isArray(fromHeader) ? fromHeader[0] : fromHeader,
+                  interceptedFrom,
                 });
                 if (answered.error != null) reportRenderError(devServer, target, answered.error);
                 if (request.method === "HEAD") await answered.stream?.cancel();

package/internal/rsc.js

@@ -407,6 +407,65 @@ export function actionReferenceSource(actions) {
   return `${lines.join("\n")}\n`;
 }
 
+/**
+ * The query that names a `"use server"` module's own source in a server graph.
+ *
+ * In a server graph the plain id of such a module answers with
+ * {@link serverActionSource}, which imports the file under this query, so the
+ * file itself is still one module and the wrapper is another.
+ */
+export const SERVER_ACTION_IMPL_QUERY = "?uf-server-impl";
+
+/**
+ * Whether a module's source declares a default export.
+ *
+ * Read off the text because the wrapper below has to decide whether to
+ * re-export `default` before anything has parsed the file — and Flow's
+ * `component` syntax is not something Rollup's parser reads. A default export
+ * is `export default …` or a name exported `as default`; a false negative
+ * leaves a non-callable default export unreachable from the server graph, and
+ * the RSC graph already refuses a `"use server"` export that is not an async
+ * function, so what is at stake is small and written down.
+ *
+ * @param {string} source
+ */
+export function declaresDefaultExport(source) {
+  return (
+    /(^|[\n;])\s*export\s+default\b/.test(source) ||
+    /export\s*\{[^}]*\b(as\s+default|default)\b[^}]*\}/.test(source)
+  );
+}
+
+/**
+ * A server graph's stand-in for one `"use server"` module.
+ *
+ * Re-exports the file's own module — every binding, the same functions — and
+ * on the way past gives each callable export the property React reads to write
+ * a form that posts before hydration (`registerServerAction` in
+ * `@uniflowed/router/action`). Nothing about calling the functions changes;
+ * the endpoint, a route handler and a server component call exactly what they
+ * called before. See ubugeeei-prod/uf#1358.
+ *
+ * @param {string} file absolute path of the module
+ * @param {Array<{id: string, module: string, export: string}>} actions its callable exports
+ * @param {boolean} hasDefault whether the file declares a default export
+ */
+export function serverActionSource(file, actions, hasDefault) {
+  const impl = JSON.stringify(`${file}${SERVER_ACTION_IMPL_QUERY}`);
+  const lines = [
+    'import { registerServerAction } from "@uniflowed/router/action";',
+    `import * as impl from ${impl};`,
+    `export * from ${impl};`,
+  ];
+  if (hasDefault) lines.push(`export { default } from ${impl};`);
+  for (const action of actions) {
+    lines.push(
+      `registerServerAction(impl[${JSON.stringify(action.export)}], ${JSON.stringify(action.id)});`,
+    );
+  }
+  return `${lines.join("\n")}\n`;
+}
+
 /**
  * The source of `virtual:uf/actions`: the table the endpoint dials into.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/vite",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Vite, driven by uf.config.js: every Flow module through `uf transform`, MDX, the file-system router and static rendering as Vite plugins.",
   "type": "module",
   "license": "MIT",
@@ -35,10 +35,10 @@
     "@babel/core": "^7.29.7",
     "@mdx-js/rollup": "^3.1.1",
     "@shikijs/rehype": "^3.23.0",
-    "@uniflowed/host": "0.1.0",
-    "@uniflowed/router": "0.1.0",
-    "@uniflowed/server": "0.1.0",
-    "@uniflowed/validator": "0.1.0",
+    "@uniflowed/host": "0.2.0",
+    "@uniflowed/router": "0.2.0",
+    "@uniflowed/server": "0.2.0",
+    "@uniflowed/validator": "0.2.0",
     "babel-plugin-relay": "^21.0.1",
     "estree-util-value-to-estree": "^3.5.0",
     "rehype-slug": "^6.0.0",