@lazarv/react-server 0.0.0-experimental-43e79e6-20230928

package/lib/plugins/react-server.mjs

@@ -0,0 +1,73 @@
+import { createReadStream } from "node:fs";
+import { createRequire } from "node:module";
+import { extname, join, relative } from "node:path";
+import { createInterface } from "node:readline";
+
+import glob from "fast-glob";
+
+import packageJson from "../../package.json" assert { type: "json" };
+import { cwd } from "../sys.mjs";
+
+const __require = createRequire(import.meta.url);
+const hmrSrc = `/${packageJson.name}/client/hmr.mjs`;
+
+async function readFirstLine(path) {
+  const inputStream = createReadStream(path);
+  try {
+    for await (const line of createInterface(inputStream)) return line;
+    return ""; // If the file is empty.
+  } finally {
+    inputStream.destroy(); // Destroy file stream.
+  }
+}
+
+export default function viteReactServer(type) {
+  return {
+    name: "react-server",
+    async config(config) {
+      if (type) {
+        const extensions = config.resolve?.extensions || [
+          ".mjs",
+          ".js",
+          ".mts",
+          ".ts",
+          ".jsx",
+          ".tsx",
+        ];
+        const pattern = join(
+          cwd(),
+          `**/*{.${extensions.map((ext) => ext.slice(1)).join(",")}}`
+        );
+        const entries = await glob(pattern, {
+          ignore: ["**/node_modules/**/*"],
+        });
+        for (const entry of entries) {
+          const firstLine = await readFirstLine(entry);
+          if (
+            firstLine.includes(`"use client";`) ||
+            firstLine.includes(`'use client';`)
+          ) {
+            const specifier = relative(cwd(), entry);
+            if (!specifier.startsWith("..")) {
+              const name = specifier.replace(extname(specifier), "");
+              config.build.rollupOptions.input[`${type}/${name}`] = entry;
+            }
+          }
+        }
+      }
+    },
+    load(id) {
+      if (id === hmrSrc) {
+        return `
+				import RefreshRuntime from "/@react-refresh";
+				RefreshRuntime.injectIntoGlobalHook(window);
+				window.$RefreshReg$ = () => {};
+				window.$RefreshSig$ = () => (type) => type;
+				window.__vite_plugin_react_preamble_installed__ = true;
+				console.log("Hot Module Replacement installed.");
+				import("${__require.resolve("@lazarv/react-server/client/entry.client.jsx")}");
+			`;
+      }
+    },
+  };
+}

package/lib/plugins/use-client.mjs

@@ -0,0 +1,135 @@
+import * as acorn from "acorn";
+import * as escodegen from "escodegen";
+import * as estraverse from "estraverse";
+
+export default function useClient() {
+  return {
+    name: "use-client",
+    async transform(code, id) {
+      const firstLine = code.slice(0, code.indexOf("\n"));
+      if (
+        firstLine.includes('"use client"') ||
+        firstLine.includes("'use client'")
+      ) {
+        const ast = acorn.parse(code, {
+          sourceType: "module",
+          ecmaVersion: 2021,
+          sourceFile: id,
+          locations: true,
+        });
+
+        estraverse.replace(ast, {
+          leave(node) {
+            if (node.type === "Program") {
+              node.body.unshift({
+                type: "ImportDeclaration",
+                specifiers: [
+                  {
+                    type: "ImportSpecifier",
+                    imported: {
+                      type: "Identifier",
+                      name: "client$",
+                    },
+                    local: {
+                      type: "Identifier",
+                      name: "__react_server_client$__",
+                    },
+                  },
+                ],
+                source: {
+                  type: "Literal",
+                  value: "@lazarv/react-server/client/components.mjs",
+                },
+                loc: {
+                  start: { line: 1, column: 0 },
+                  end: { line: 1, column: 0 },
+                },
+              });
+            }
+          },
+          enter(node) {
+            if (node.type === "ExportNamedDeclaration") {
+              if (node.declaration.type === "VariableDeclaration") {
+                for (const declaration of node.declaration.declarations) {
+                  if (
+                    declaration.init.type === "ArrowFunctionExpression" ||
+                    declaration.init.type === "FunctionExpression"
+                  ) {
+                    declaration.init = {
+                      type: "CallExpression",
+                      callee: {
+                        type: "Identifier",
+                        name: "__react_server_client$__",
+                      },
+                      arguments: [
+                        declaration.init,
+                        { type: "Literal", value: declaration.id.name },
+                      ],
+                    };
+                  }
+                }
+              } else if (
+                node.declaration.type === "FunctionDeclaration" ||
+                node.declaration.type === "Identifier"
+              ) {
+                node.declaration = {
+                  type: "VariableDeclaration",
+                  kind: "const",
+                  declarations: [
+                    {
+                      type: "VariableDeclarator",
+                      id: {
+                        type: "Identifier",
+                        name: node.declaration.id.name,
+                      },
+                      init: {
+                        type: "CallExpression",
+                        callee: {
+                          type: "Identifier",
+                          name: "__react_server_client$__",
+                        },
+                        arguments: [
+                          node.declaration,
+                          { type: "Literal", value: node.declaration.id.name },
+                        ],
+                      },
+                    },
+                  ],
+                };
+              }
+            } else if (node.type === "ExportDefaultDeclaration") {
+              if (
+                node.declaration.type === "ArrowFunctionExpression" ||
+                node.declaration.type === "FunctionExpression" ||
+                node.declaration.type === "FunctionDeclaration" ||
+                node.declaration.type === "Identifier"
+              ) {
+                node.declaration = {
+                  type: "CallExpression",
+                  callee: {
+                    type: "Identifier",
+                    name: "__react_server_client$__",
+                  },
+                  arguments: [
+                    node.declaration,
+                    { type: "Literal", value: "default" },
+                  ],
+                };
+              }
+            }
+          },
+        });
+
+        const gen = escodegen.generate(ast, {
+          sourceMap: true,
+          sourceMapWithCode: true,
+        });
+
+        return {
+          code: gen.code,
+          map: gen.map.toString(),
+        };
+      }
+    },
+  };
+}

package/lib/plugins/use-server.mjs

@@ -0,0 +1,175 @@
+import * as acorn from "acorn";
+import * as escodegen from "escodegen";
+import * as estraverse from "estraverse";
+
+export default function useServer() {
+  return {
+    name: "use-server",
+    async transform(code, id) {
+      // exclude node_modules
+      if (/node_modules/.test(id)) return;
+
+      if (code.includes('"use server"') || code.includes("'use server'")) {
+        try {
+          const ast = acorn.parse(code, {
+            sourceType: "module",
+            ecmaVersion: 2021,
+            sourceFile: id,
+            locations: true,
+          });
+
+          let serverRoot = false;
+          let exportContext = false;
+          const result = estraverse.replace(ast, {
+            leave(node) {
+              if (
+                node.type === "ExportNamedDeclaration" ||
+                node.type === "ExportDefaultDeclaration"
+              ) {
+                exportContext = false;
+              }
+
+              if (node.type === "Program") {
+                node.body.unshift({
+                  type: "ImportDeclaration",
+                  specifiers: [
+                    {
+                      type: "ImportSpecifier",
+                      imported: {
+                        type: "Identifier",
+                        name: "server$",
+                      },
+                      local: {
+                        type: "Identifier",
+                        name: "__react_server_server$__",
+                      },
+                    },
+                  ],
+                  source: {
+                    type: "Literal",
+                    value: "@lazarv/react-server",
+                  },
+                  loc: {
+                    start: { line: 1, column: 0 },
+                    end: { line: 1, column: 0 },
+                  },
+                });
+              }
+            },
+            enter(node, parent) {
+              if (
+                node.type === "ExpressionStatement" &&
+                node.directive === "use server" &&
+                parent.type === "Program" &&
+                parent.body.indexOf(node) === 0
+              ) {
+                serverRoot = true;
+              }
+
+              if (
+                node.type === "ExportNamedDeclaration" ||
+                node.type === "ExportDefaultDeclaration"
+              ) {
+                exportContext = true;
+              }
+
+              if (node.type === "BlockStatement") {
+                exportContext = false;
+              }
+
+              let actionName;
+              let serverNode;
+              if (
+                (node.type === "FunctionDeclaration" ||
+                  node.type === "FunctionExpression" ||
+                  node.type === "ArrowFunctionExpression") &&
+                ((serverRoot && exportContext) ||
+                  (node.body?.type === "BlockStatement" &&
+                    node.body?.body?.[0]?.type === "ExpressionStatement" &&
+                    node.body?.body?.[0]?.directive === "use server"))
+              ) {
+                if (node.id?.type === "Identifier") {
+                  actionName = node.id.name;
+                }
+                serverNode = {
+                  type: "CallExpression",
+                  callee: {
+                    type: "Identifier",
+                    name: "__react_server_server$__",
+                  },
+                  arguments: [node],
+                  loc: node.loc,
+                };
+              }
+
+              if (serverNode) {
+                if (parent.type === "Property") {
+                  parent.value = serverNode;
+                } else if (parent.type === "ArrayExpression") {
+                  parent.elements[parent.elements.indexOf(node)] = serverNode;
+                } else if (parent.type === "VariableDeclarator") {
+                  parent.init = serverNode;
+                } else if (
+                  parent.type === "AssignmentExpression" ||
+                  parent.type === "AssignmentPattern"
+                ) {
+                  parent.right = serverNode;
+                } else if (parent.type === "ReturnStatement") {
+                  parent.argument = serverNode;
+                } else if (parent.type === "CallExpression") {
+                  parent.arguments[parent.arguments.indexOf(node)] = serverNode;
+                } else if (parent.type === "ExportDefaultDeclaration") {
+                  parent.declaration = serverNode;
+                } else if (parent.type === "ExportNamedDeclaration") {
+                  parent.declaration = {
+                    type: "VariableDeclaration",
+                    kind: "const",
+                    declarations: [
+                      {
+                        type: "VariableDeclarator",
+                        id: {
+                          type: "Identifier",
+                          name: actionName,
+                        },
+                        init: serverNode,
+                      },
+                    ],
+                    loc: parent.declaration.loc,
+                  };
+                } else if (parent.type === "BlockStatement") {
+                  parent.body[parent.body.indexOf(node)] = {
+                    type: "VariableDeclaration",
+                    kind: "const",
+                    declarations: [
+                      {
+                        type: "VariableDeclarator",
+                        id: {
+                          type: "Identifier",
+                          name: actionName,
+                        },
+                        init: serverNode,
+                      },
+                    ],
+                    loc: node.loc,
+                  };
+                }
+              }
+            },
+          });
+
+          const gen = escodegen.generate(result, {
+            sourceMap: true,
+            sourceMapWithCode: true,
+          });
+
+          return {
+            code: gen.code,
+            map: gen.map.toString(),
+          };
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    },
+  };
+}

package/lib/start/action.mjs

@@ -0,0 +1,110 @@
+import cluster from "node:cluster";
+import { once } from "node:events";
+import { createRequire } from "node:module";
+import { availableParallelism } from "node:os";
+
+import { loadConfig } from "../../config/index.mjs";
+import { logger } from "../../server/logger.mjs";
+import { init$ as runtime_init$, runtime$ } from "../../server/runtime.mjs";
+import {
+  CONFIG_CONTEXT,
+  CONFIG_ROOT,
+  LOGGER_CONTEXT,
+  SERVER_CONTEXT,
+} from "../../server/symbols.mjs";
+import getServerAddresses from "../utils/server-address.mjs";
+import createServer from "./create-server.mjs";
+
+const __require = createRequire(import.meta.url);
+
+function primary(numCPUs) {
+  // fork workers
+  for (let i = 0; i < numCPUs; i++) {
+    cluster.fork();
+  }
+
+  cluster.on("exit", () => {
+    process.exit(1);
+  });
+
+  process.on("SIGINT", () => {
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    process.exit(0);
+  });
+}
+
+async function worker(root, options) {
+  const config = await loadConfig();
+  const configRoot = config[CONFIG_ROOT];
+
+  await runtime_init$(async () => {
+    runtime$(CONFIG_CONTEXT, config);
+
+    if (!configRoot?.logger || typeof configRoot?.logger === "string") {
+      const { default: loggerModule } = await import(
+        __require.resolve(configRoot?.logger ?? "pino")
+      );
+      const logger = loggerModule();
+      runtime$(LOGGER_CONTEXT, logger);
+    } else {
+      runtime$(LOGGER_CONTEXT, configRoot?.logger);
+    }
+
+    const server = await createServer(root, options);
+
+    const port = options.port ?? configRoot.port;
+    const host = options.host ?? configRoot.host;
+    const listenerHost = host === true ? undefined : host;
+
+    const listener = server.listen(port, listenerHost);
+    runtime$(SERVER_CONTEXT, listener);
+    await once(listener, "listening");
+
+    getServerAddresses(listener).forEach((address) =>
+      logger.info(
+        `worker #${process.pid} listening on ${
+          config.server?.https || options.https ? "https" : "http"
+        }://${address.address}:${listener.address().port}`
+      )
+    );
+  });
+}
+
+export default async function start(root, options) {
+  if (options.build) {
+    const { default: build } = await import("../build/action.mjs");
+    await build(options.build, options);
+  }
+
+  try {
+    const config = await loadConfig();
+    const configRoot = config[CONFIG_ROOT];
+
+    try {
+      let numCPUs = parseInt(
+        process.env.REACT_SERVER_CLUSTER || configRoot?.cluster,
+        10
+      );
+
+      if (isNaN(numCPUs) && process.env.REACT_SERVER_CLUSTER) {
+        numCPUs = availableParallelism();
+      }
+
+      if (
+        numCPUs > 1 &&
+        (process.env.REACT_SERVER_CLUSTER || configRoot?.cluster) &&
+        cluster.isPrimary
+      ) {
+        primary(numCPUs);
+      } else {
+        worker(root, options);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  } catch (error) {
+    console.error(error);
+  }
+}

package/lib/start/create-server.mjs

@@ -0,0 +1,111 @@
+import { join } from "node:path";
+
+import { createMiddleware } from "@hattip/adapter-node";
+import { compose } from "@hattip/compose";
+import { cookie } from "@hattip/cookie";
+import { cors } from "@hattip/cors";
+import { parseMultipartFormData } from "@hattip/multipart";
+
+import { MemoryCache } from "../../memory-cache/index.mjs";
+import { getRuntime, runtime$ } from "../../server/runtime.mjs";
+import {
+  CONFIG_CONTEXT,
+  CONFIG_ROOT,
+  FORM_DATA_PARSER,
+  LOGGER_CONTEXT,
+  MEMORY_CACHE_CONTEXT,
+} from "../../server/symbols.mjs";
+import notFoundHandler from "../handlers/not-found.mjs";
+import staticHandler from "../handlers/static.mjs";
+import trailingSlashHandler from "../handlers/trailing-slash.mjs";
+import { cwd } from "../sys.mjs";
+import ssrHandler from "./ssr-handler.mjs";
+
+export default async function createServer(root, options) {
+  const config = getRuntime(CONFIG_CONTEXT)?.[CONFIG_ROOT] ?? {};
+  const logger = getRuntime(LOGGER_CONTEXT);
+
+  const initialRuntime = {
+    [MEMORY_CACHE_CONTEXT]: new MemoryCache(),
+    [FORM_DATA_PARSER]: parseMultipartFormData,
+  };
+  runtime$(
+    typeof config.runtime === "function"
+      ? config.runtime(initialRuntime) ?? initialRuntime
+      : {
+          ...initialRuntime,
+          ...config.runtime,
+        }
+  );
+
+  const publicDir =
+    typeof config.publicDir === "string" ? config.publicDir : "public";
+  const initialHandlers = [
+    await staticHandler("{client,assets}", { cwd: ".react-server" }),
+    await staticHandler(join(cwd(), ".react-server/dist"), {
+      cwd: ".react-server/dist",
+    }),
+    await staticHandler(join(cwd(), ".react-server"), {
+      cwd: ".react-server",
+    }),
+    ...(config.publicDir !== false
+      ? [
+          await staticHandler(join(cwd(), publicDir), {
+            cwd: publicDir,
+          }),
+        ]
+      : []),
+    await trailingSlashHandler(),
+    cookie(),
+    ...(config.handlers?.pre ?? []),
+    await ssrHandler(root),
+    ...(config.handlers?.post ?? []),
+    await notFoundHandler(),
+  ];
+  if (options.cors) {
+    logger.info("CORS enabled");
+    initialHandlers.unshift(cors());
+  }
+
+  const middlewares = createMiddleware(
+    compose(
+      typeof config.handlers === "function"
+        ? config.handlers(initialHandlers) ?? initialHandlers
+        : [...initialHandlers, ...(config.handlers ?? [])]
+    ),
+    {
+      origin:
+        config.server?.origin ??
+        options.origin ??
+        process.env.ORIGIN ??
+        `${
+          config.server?.https || options.https ? "https" : "http"
+        }://localhost:${config.server?.port ?? options.port}`,
+      trustProxy: config.server?.trustProxy ?? options.trustProxy,
+    }
+  );
+
+  const httpsOptions = config.server?.https ?? options.https;
+  if (!httpsOptions) {
+    const { createServer } = await import("node:http");
+    return createServer(middlewares);
+  }
+
+  // #484 fallback to http1 when proxy is needed.
+  if (config.server?.proxy) {
+    const { createServer } = await import("node:https");
+    return createServer(httpsOptions, middlewares);
+  } else {
+    const { createSecureServer } = await import("node:http2");
+    return createSecureServer(
+      {
+        // Manually increase the session memory to prevent 502 ENHANCE_YOUR_CALM
+        // errors on large numbers of requests
+        maxSessionMemory: 1000,
+        ...httpsOptions,
+        allowHTTP1: true,
+      },
+      middlewares
+    );
+  }
+}