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

package/lib/start/manifest.mjs

@@ -0,0 +1,104 @@
+import { createRequire } from "node:module";
+
+import { getContext } from "../../server/context.mjs";
+import { runtime$ } from "../../server/runtime.mjs";
+import {
+  COLLECT_STYLESHEETS,
+  HTTP_CONTEXT,
+  MAIN_MODULE,
+  MANIFEST,
+  MODULE_LOADER,
+} from "../../server/symbols.mjs";
+
+const __require = createRequire(import.meta.url);
+
+export async function init$() {
+  const serverManifest = __require.resolve(
+    "./.react-server/server/manifest.json",
+    {
+      paths: [process.cwd()],
+    }
+  );
+  const clientManifest = __require.resolve(
+    "./.react-server/client/manifest.json",
+    {
+      paths: [process.cwd()],
+    }
+  );
+  const [{ default: server }, { default: client }] = await Promise.all([
+    import(serverManifest, { assert: { type: "json" } }),
+    import(clientManifest, { assert: { type: "json" } }),
+  ]);
+  const manifest = {
+    server,
+    client,
+  };
+  runtime$(MANIFEST, manifest);
+
+  const mainModule = `/${
+    Object.values(manifest.client).find(
+      (entry) => entry.src === "../../client/entry.client.jsx"
+    ).file
+  }`;
+  runtime$(MAIN_MODULE, [mainModule]);
+
+  const entryCache = new Map();
+  function ssrLoadModule($$id) {
+    const httpContext = getContext(HTTP_CONTEXT);
+    const [id /*, name*/] = $$id
+      .replace(
+        `${
+          httpContext?.request?.headers?.get("x-forwarded-for") ||
+          new URL(httpContext?.url).origin
+        }/`,
+        ""
+      )
+      .split("::");
+    try {
+      const moduleUri = new URL(id);
+      if (moduleUri.protocol === "http:" || moduleUri.protocol === "https:") {
+        return import(id);
+      }
+    } catch (e) {
+      // noop
+    }
+    if (entryCache.has(id)) {
+      return import(entryCache.get(id));
+    }
+    const clientEntry = Object.values(manifest.client).find((entry) =>
+      entry.file.endsWith(id)
+    );
+    const serverEntry = Object.values(manifest.server).find((entry) =>
+      entry.src.endsWith(clientEntry.src)
+    );
+    const specifier = __require.resolve(`./.react-server/${serverEntry.file}`, {
+      paths: [process.cwd()],
+    });
+    entryCache.set(id, specifier);
+    return import(specifier);
+  }
+  runtime$(MODULE_LOADER, ssrLoadModule);
+
+  function collectStylesheets(rootModule) {
+    if (!rootModule) return [];
+    const rootManifest = Array.from(Object.values(manifest.server)).find(
+      (entry) =>
+        rootModule.endsWith(entry.file) || entry.src.endsWith(rootModule)
+    );
+    const styles = [];
+    function collectCss(entry) {
+      if (!entry) return styles;
+      if (entry.css) {
+        styles.push(...entry.css.map((href) => `/${href}`));
+      }
+      if (entry.imports) {
+        entry.imports.forEach((imported) =>
+          collectCss(manifest.server[imported])
+        );
+      }
+    }
+    collectCss(rootManifest);
+    return styles;
+  }
+  runtime$(COLLECT_STYLESHEETS, collectStylesheets);
+}

package/lib/start/ssr-handler.mjs

@@ -0,0 +1,134 @@
+import { createRequire } from "node:module";
+
+import { forChild } from "../../config/index.mjs";
+import { init$ as memory_cache_init$ } from "../../memory-cache/index.mjs";
+import { ContextStorage, getContext } from "../../server/context.mjs";
+import { logger } from "../../server/logger.mjs";
+import { init$ as module_loader_init$ } from "../../server/module-loader.mjs";
+import { getRuntime } from "../../server/runtime.mjs";
+import {
+  COLLECT_STYLESHEETS,
+  CONFIG_CONTEXT,
+  CONFIG_ROOT,
+  ERROR_CONTEXT,
+  FORM_DATA_PARSER,
+  HTTP_CONTEXT,
+  LOGGER_CONTEXT,
+  MAIN_MODULE,
+  MANIFEST,
+  MEMORY_CACHE_CONTEXT,
+  MODULE_LOADER,
+  REDIRECT_CONTEXT,
+  SERVER_CONTEXT,
+  STYLES_CONTEXT,
+} from "../../server/symbols.mjs";
+import errorHandler from "../handlers/error.mjs";
+import { init$ as manifest_init$ } from "./manifest.mjs";
+
+const __require = createRequire(import.meta.url);
+
+const defaultRoot = `${process.cwd()}/.react-server/server/index.mjs`;
+export default async function ssrHandler(root) {
+  const config = getRuntime(CONFIG_CONTEXT);
+  const configRoot = config?.[CONFIG_ROOT] ?? {};
+
+  await manifest_init$();
+
+  const entryModule = __require.resolve(
+    `${process.cwd()}/.react-server/server/entry.mjs`
+  );
+  const rootModule = __require.resolve(
+    root ?? configRoot.entry ?? defaultRoot,
+    {
+      paths: [process.cwd()],
+    }
+  );
+  const { render } = await import(entryModule);
+  const { default: Component, init$: root_init$ } = await import(rootModule);
+  const collectStylesheets = getRuntime(COLLECT_STYLESHEETS);
+  const styles = getRuntime(COLLECT_STYLESHEETS)?.(rootModule) ?? [];
+  const mainModule = getRuntime(MAIN_MODULE);
+  const formDataParser = getRuntime(FORM_DATA_PARSER);
+  const moduleLoader = getRuntime(MODULE_LOADER);
+  const memoryCache = getRuntime(MEMORY_CACHE_CONTEXT);
+  const manifest = getRuntime(MANIFEST);
+  await module_loader_init$(moduleLoader);
+
+  return async (httpContext) => {
+    // const accept = httpContext.request.headers.get("accept");
+    // if (
+    //   !accept ||
+    //   !(accept.includes("text/html") || accept.includes("text/x-component"))
+    // ) {
+    //   return;
+    // }
+    return new Promise((resolve, reject) => {
+      try {
+        ContextStorage.run(
+          {
+            [SERVER_CONTEXT]: getRuntime(SERVER_CONTEXT),
+            [CONFIG_CONTEXT]: config,
+            [HTTP_CONTEXT]: httpContext,
+            [ERROR_CONTEXT]: errorHandler,
+            [LOGGER_CONTEXT]: logger,
+            [MAIN_MODULE]: mainModule,
+            [FORM_DATA_PARSER]: formDataParser,
+            [MODULE_LOADER]: moduleLoader,
+            [MEMORY_CACHE_CONTEXT]: memoryCache,
+            [MANIFEST]: manifest,
+            [REDIRECT_CONTEXT]: {},
+            [COLLECT_STYLESHEETS]: collectStylesheets,
+            [STYLES_CONTEXT]: styles,
+          },
+          async () => {
+            const cacheModule = forChild(httpContext.url)?.cache?.module;
+
+            if (cacheModule) {
+              const { init$: cache_init$ } = await import(
+                __require.resolve(cacheModule, {
+                  paths: [process.cwd()],
+                })
+              );
+              await cache_init$?.();
+            } else {
+              await memory_cache_init$?.();
+            }
+
+            try {
+              const middlewares = await root_init$?.();
+              if (middlewares) {
+                const response = await middlewares(httpContext);
+                if (response) {
+                  return resolve(response);
+                }
+              }
+            } catch (e) {
+              const redirect = getContext(REDIRECT_CONTEXT);
+              if (redirect?.response) {
+                return resolve(redirect.response);
+              }
+            }
+
+            const accept = httpContext.request.headers.get("accept");
+            if (
+              !accept ||
+              !(
+                accept.includes("text/html") ||
+                accept.includes("text/x-component") ||
+                accept.includes("application/json")
+              )
+            ) {
+              return resolve();
+            }
+
+            const styles = getContext(STYLES_CONTEXT);
+            render(Component, styles).then(resolve, reject);
+          }
+        );
+      } catch (e) {
+        logger.error(e);
+        errorHandler(e).then(resolve);
+      }
+    });
+  };
+}

package/lib/sys.mjs

@@ -0,0 +1,49 @@
+export function cwd() {
+  return typeof Deno !== "undefined" ? Deno.cwd() : process.cwd();
+}
+
+export function argv() {
+  return typeof Deno !== "undefined"
+    ? [Deno.execPath(), Deno.mainModule, ...Deno.args]
+    : process.argv;
+}
+
+export function exit(code) {
+  typeof Deno !== "undefined" ? Deno.exit(code) : process.exit(code);
+}
+
+export function getEnv(name) {
+  return typeof Deno !== "undefined" ? Deno.env.get(name) : process.env[name];
+}
+
+export function setEnv(name, value) {
+  typeof Deno !== "undefined"
+    ? Deno.env.set(name, value)
+    : (process.env[name] = value);
+}
+
+export function copyBytesFrom(buffer) {
+  return typeof Deno !== "undefined"
+    ? new Uint8Array(buffer)
+    : Buffer.copyBytesFrom(buffer);
+}
+
+export function concat(buffers) {
+  return typeof Deno !== "undefined"
+    ? new Uint8Array(buffers.reduce((acc, buf) => [...acc, ...buf], []))
+    : Buffer.concat(buffers);
+}
+
+export function immediate(fn) {
+  return typeof Deno !== "undefined" ? fn() : setImmediate(fn);
+}
+
+if (typeof Deno !== "undefined") {
+  globalThis.process = {
+    env: Deno.env.toObject(),
+    cwd: Deno.cwd,
+    argv: [Deno.execPath(), Deno.mainModule, ...Deno.args],
+    exit: Deno.exit,
+    emit: function () {},
+  };
+}

package/lib/utils/merge.mjs

@@ -0,0 +1,31 @@
+function isObject(item) {
+  return (
+    item &&
+    typeof item === "object" &&
+    !Array.isArray(item) &&
+    Object.getPrototypeOf(item) === Object.prototype
+  );
+}
+
+export default function mergeDeep(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key])
+          Object.assign(target, {
+            [key]: {},
+          });
+        mergeDeep(target[key], source[key]);
+      } else {
+        Object.assign(target, {
+          [key]: source[key],
+        });
+      }
+    }
+  }
+
+  return mergeDeep(target, ...sources);
+}

package/lib/utils/server-address.mjs

@@ -0,0 +1,14 @@
+import { networkInterfaces } from "node:os";
+
+export default function getServerAddresses(server) {
+  const serverAddress = server.address();
+  const addresses = Object.values(networkInterfaces());
+  return (
+    addresses.find((addresses) =>
+      addresses.some((address) => address.address === serverAddress.address),
+    ) ||
+    addresses.flatMap((addresses) =>
+      addresses.filter((address) => address.family === "IPv4"),
+    )
+  ).filter((address) => address.family === "IPv4");
+}

package/memory-cache/index.mjs

@@ -0,0 +1,125 @@
+import { context$, getContext } from "../server/context.mjs";
+import { CACHE_CONTEXT, MEMORY_CACHE_CONTEXT } from "../server/symbols.mjs";
+
+export class MemoryCache {
+  constructor() {
+    this.cache = new Map();
+    this.expiry = new Map();
+  }
+
+  async get(keys) {
+    const now = Date.now();
+
+    const expiryEntries = this.expiry.entries();
+    const deleteQueue = [];
+    for (const [expiryKeys, expiry] of expiryEntries) {
+      if (expiry < now) {
+        this.expiry.delete(expiryKeys);
+        deleteQueue.push(this.delete(expiryKeys));
+      }
+    }
+    await Promise.all(deleteQueue);
+
+    const cacheKeys = this.cache.keys();
+    for (const entryKeys of cacheKeys) {
+      if (
+        keys.every((key, keyIndex) => entryKeys[keyIndex] === key?.toString())
+      ) {
+        return this.cache.get(entryKeys);
+      }
+    }
+
+    return null;
+  }
+
+  async set(keys, value) {
+    if (await this.hasExpiry(keys)) {
+      const cacheKeys = this.cache.keys();
+      for (const entryKeys of cacheKeys) {
+        if (
+          keys.every((key, keyIndex) => entryKeys[keyIndex] === key?.toString())
+        ) {
+          this.cache.set(entryKeys, value);
+          return;
+        }
+      }
+      this.cache.set(
+        keys.map((key) => key?.toString()),
+        value
+      );
+    }
+  }
+
+  async has(keys) {
+    const cacheKeys = this.cache.keys();
+    for (const entryKeys of cacheKeys) {
+      if (
+        keys.every((key, keyIndex) => entryKeys[keyIndex] === key?.toString())
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  async setExpiry(keys, expiry) {
+    const expiryKeys = this.expiry.keys();
+    for (const entryKeys of expiryKeys) {
+      if (
+        keys.every((key, keyIndex) => entryKeys[keyIndex] === key?.toString())
+      ) {
+        this.expiry.set(entryKeys, expiry);
+        return;
+      }
+    }
+    this.expiry.set(
+      keys.map((key) => key?.toString()),
+      expiry
+    );
+  }
+
+  async hasExpiry(keys) {
+    const expiryKeys = this.expiry.keys();
+    for (const entryKeys of expiryKeys) {
+      for (let keyIndex = 0; keyIndex < entryKeys.length; keyIndex++) {
+        const key = keys[keyIndex];
+        if (entryKeys[keyIndex] !== key?.toString()) {
+          break;
+        }
+        if (keyIndex === entryKeys.length - 1) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  async delete(keys) {
+    const cacheKeys = this.cache.keys();
+    for (const entryKeys of cacheKeys) {
+      if (
+        keys.every((key, keyIndex) => entryKeys[keyIndex] === key?.toString())
+      ) {
+        this.cache.delete(entryKeys);
+      }
+    }
+  }
+}
+
+const cache = new MemoryCache();
+export async function init$() {
+  return context$(CACHE_CONTEXT, cache);
+}
+
+export async function useCache(keys, promise, ttl = Infinity, force = false) {
+  const cache = getContext(MEMORY_CACHE_CONTEXT);
+  let result = await cache.get(keys);
+  if (force || result === null) {
+    result = typeof promise === "function" ? await promise() : promise;
+    await cache.setExpiry(keys, Date.now() + ttl);
+    await cache.set(keys, result);
+  }
+  return result;
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@lazarv/react-server",
+  "version": "0.0.0-experimental-43e79e6-20230928",
+  "description": "Experimental React meta-framework using Vite",
+  "type": "module",
+  "module": "server/index.mjs",
+  "bin": "bin/cli.mjs",
+  "types": "react-server.d.ts",
+  "exports": {
+    ".": "./server/index.mjs",
+    "./client": "./client/index.jsx",
+    "./config": "./config/index.mjs",
+    "./error-boundary": "./server/error-boundary.jsx",
+    "./memory-cache": "./memory-cache/index.mjs",
+    "./navigation": "./client/navigation.jsx",
+    "./remote-component": "./server/remote-component.jsx",
+    "./router": "./server/router.jsx",
+    "./client/*": "./client/*",
+    "./server/*": "./server/*",
+    "./lib/*": "./lib/*",
+    "./*": "./*"
+  },
+  "keywords": [
+    "react",
+    "ssr",
+    "esm",
+    "server"
+  ],
+  "author": "lazarv",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lazarv/react-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lazarv/react-server/issues"
+  },
+  "dependencies": {
+    "@hattip/adapter-node": "^0.0.34",
+    "@hattip/compose": "^0.0.34",
+    "@hattip/cookie": "^0.0.34",
+    "@hattip/core": "^0.0.34",
+    "@hattip/cors": "^0.0.34",
+    "@hattip/headers": "^0.0.34",
+    "@hattip/multipart": "^0.0.34",
+    "@rollup/plugin-replace": "^5.0.2",
+    "@vitejs/plugin-react": "^4.0.1",
+    "acorn": "^8.10.0",
+    "cac": "^6.7.14",
+    "esbuild": "^0.19.3",
+    "escodegen": "^2.1.0",
+    "estraverse": "^5.3.0",
+    "fast-glob": "^3.2.12",
+    "filesize": "^10.0.12",
+    "mime": "^3.0.0",
+    "module-alias": "^2.2.3",
+    "open": "^9.1.0",
+    "picocolors": "^1.0.0",
+    "pino": "^8.14.1",
+    "rimraf": "^5.0.1",
+    "sass": "^1.63.6",
+    "strip-ansi": "^7.1.0",
+    "vite": "^4.4.9"
+  },
+  "peerDependencies": {
+    "react": "0.0.0-experimental-41f0e9dae-20230907",
+    "react-dom": "0.0.0-experimental-41f0e9dae-20230907",
+    "react-error-boundary": "^4.0.10",
+    "react-server-dom-webpack": "0.0.0-experimental-41f0e9dae-20230907"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "react": "0.0.0-experimental-41f0e9dae-20230907",
+    "react-dom": "0.0.0-experimental-41f0e9dae-20230907",
+    "react-error-boundary": "^4.0.10",
+    "react-server-dom-webpack": "0.0.0-experimental-41f0e9dae-20230907"
+  },
+  "scripts": {}
+}