@rpcbase/server 0.441.0 → 0.443.0

package/dist/applyRouteLoaders.d.ts

@@ -0,0 +1,4 @@
+import { Request } from 'express';
+import { StaticHandlerContext } from '../../router/src';
+export declare function applyRouteLoaders(req: Request, dataRoutes: any[]): Promise<StaticHandlerContext>;
+//# sourceMappingURL=applyRouteLoaders.d.ts.map

package/dist/applyRouteLoaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyRouteLoaders.d.ts","sourceRoot":"","sources":["../src/applyRouteLoaders.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,OAAO,EAAC,MAAM,SAAS,CAAA;AAC/B,OAAO,EACL,oBAAoB,EAMrB,MAAM,iBAAiB,CAAA;AAsDxB,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,GAAG,EAAE,GAChB,OAAO,CAAC,oBAAoB,CAAC,CAkG/B"}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './initServer';
 export * from './getDerivedKey';
 export * from './hashPassword';
+export * from './ssrMiddleware';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA"}

package/dist/index.js

@@ -1,12 +1,191 @@
 import session from "express-session";
 import { RedisStore } from "connect-redis";
+import MongoStore from "connect-mongo";
 import { createClient } from "redis";
-import requestIp from "request-ip";
 import env from "@rpcbase/env";
-import { initApiClient } from "@rpcbase/client";
+import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
 import assert from "assert";
 import { hkdfSync, scrypt } from "crypto";
 import { createProxyMiddleware } from "http-proxy-middleware";
+import fs from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { Transform } from "node:stream";
+import { StrictMode, createElement } from "react";
+import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
+import { jsx } from "react/jsx-runtime";
+import { createPath, matchRoutes, parsePath, createStaticRouter, StaticRouterProvider } from "@rpcbase/router";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var is_1;
+var hasRequiredIs;
+function requireIs() {
+  if (hasRequiredIs) return is_1;
+  hasRequiredIs = 1;
+  var regexes = {
+    ipv4: /^(?:(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])$/,
+    ipv6: /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i
+  };
+  function not(func) {
+    return function() {
+      return !func.apply(null, Array.prototype.slice.call(arguments));
+    };
+  }
+  function existy(value) {
+    return value != null;
+  }
+  function ip(value) {
+    return existy(value) && regexes.ipv4.test(value) || regexes.ipv6.test(value);
+  }
+  function object(value) {
+    return Object(value) === value;
+  }
+  function string(value) {
+    return Object.prototype.toString.call(value) === "[object String]";
+  }
+  var is = {
+    existy,
+    ip,
+    object,
+    string,
+    not: {
+      existy: not(existy),
+      ip: not(ip),
+      object: not(object),
+      string: not(string)
+    }
+  };
+  is_1 = is;
+  return is_1;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
+  var is = requireIs();
+  function getClientIpFromXForwardedFor(value) {
+    if (!is.existy(value)) {
+      return null;
+    }
+    if (is.not.string(value)) {
+      throw new TypeError('Expected a string, got "'.concat(_typeof(value), '"'));
+    }
+    var forwardedIps = value.split(",").map(function(e) {
+      var ip = e.trim();
+      if (ip.includes(":")) {
+        var splitted = ip.split(":");
+        if (splitted.length === 2) {
+          return splitted[0];
+        }
+      }
+      return ip;
+    });
+    for (var i = 0; i < forwardedIps.length; i++) {
+      if (is.ip(forwardedIps[i])) {
+        return forwardedIps[i];
+      }
+    }
+    return null;
+  }
+  function getClientIp(req) {
+    if (req.headers) {
+      if (is.ip(req.headers["x-client-ip"])) {
+        return req.headers["x-client-ip"];
+      }
+      var xForwardedFor = getClientIpFromXForwardedFor(req.headers["x-forwarded-for"]);
+      if (is.ip(xForwardedFor)) {
+        return xForwardedFor;
+      }
+      if (is.ip(req.headers["cf-connecting-ip"])) {
+        return req.headers["cf-connecting-ip"];
+      }
+      if (is.ip(req.headers["fastly-client-ip"])) {
+        return req.headers["fastly-client-ip"];
+      }
+      if (is.ip(req.headers["true-client-ip"])) {
+        return req.headers["true-client-ip"];
+      }
+      if (is.ip(req.headers["x-real-ip"])) {
+        return req.headers["x-real-ip"];
+      }
+      if (is.ip(req.headers["x-cluster-client-ip"])) {
+        return req.headers["x-cluster-client-ip"];
+      }
+      if (is.ip(req.headers["x-forwarded"])) {
+        return req.headers["x-forwarded"];
+      }
+      if (is.ip(req.headers["forwarded-for"])) {
+        return req.headers["forwarded-for"];
+      }
+      if (is.ip(req.headers.forwarded)) {
+        return req.headers.forwarded;
+      }
+      if (is.ip(req.headers["x-appengine-user-ip"])) {
+        return req.headers["x-appengine-user-ip"];
+      }
+    }
+    if (is.existy(req.connection)) {
+      if (is.ip(req.connection.remoteAddress)) {
+        return req.connection.remoteAddress;
+      }
+      if (is.existy(req.connection.socket) && is.ip(req.connection.socket.remoteAddress)) {
+        return req.connection.socket.remoteAddress;
+      }
+    }
+    if (is.existy(req.socket) && is.ip(req.socket.remoteAddress)) {
+      return req.socket.remoteAddress;
+    }
+    if (is.existy(req.info) && is.ip(req.info.remoteAddress)) {
+      return req.info.remoteAddress;
+    }
+    if (is.existy(req.requestContext) && is.existy(req.requestContext.identity) && is.ip(req.requestContext.identity.sourceIp)) {
+      return req.requestContext.identity.sourceIp;
+    }
+    if (req.headers) {
+      if (is.ip(req.headers["Cf-Pseudo-IPv4"])) {
+        return req.headers["Cf-Pseudo-IPv4"];
+      }
+    }
+    if (is.existy(req.raw)) {
+      return getClientIp(req.raw);
+    }
+    return null;
+  }
+  function mw(options) {
+    var configuration = is.not.existy(options) ? {} : options;
+    if (is.not.object(configuration)) {
+      throw new TypeError("Options must be an object!");
+    }
+    var attributeName = configuration.attributeName || "clientIp";
+    return function(req, res, next) {
+      var ip = getClientIp(req);
+      Object.defineProperty(req, attributeName, {
+        get: function get() {
+          return ip;
+        },
+        configurable: true
+      });
+      next();
+    };
+  }
+  lib = {
+    getClientIpFromXForwardedFor,
+    getClientIp,
+    mw
+  };
+  return lib;
+}
+var libExports = requireLib();
+const requestIp = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
 const getDerivedKey = (masterKey, info, length = 32, salt = "") => {
   assert(masterKey?.length >= 32, "MASTER_KEY must be 32 chars or longer.");
   return Buffer.from(hkdfSync(
@@ -39,27 +218,33 @@ process.env = {
   ...__rb_env__,
   ...process.env
 };
-const isProduction = process.env.NODE_ENV === "production";
-const initServer = async (app, serverEnv) => {
-  await initApiClient({ app });
-  app.disable("x-powered-by");
-  app.set("trust proxy", true);
-  app.use(requestIp.mw());
-  app.use((req, res, next) => {
-    if (req.headers.host?.startsWith("www.")) {
-      const newHost = req.headers.host.replace("www.", "");
-      return res.redirect(301, `${req.protocol}://${newHost}${req.originalUrl}`);
-    }
-    next();
-  });
-  metricsIngestProxyMiddleware(app);
-  if (!serverEnv.REDIS_URL) {
-    console.log("WARNING", "missing REDIS_URL, will skip session storage middleware");
-    return;
-  } else {
-    console.log("REDIS_URL:", serverEnv.REDIS_URL);
+const isProduction$1 = process.env.NODE_ENV === "production";
+const SESSION_MAX_AGE_S = 3600 * 24 * 60;
+const getMongoUrl = (serverEnv) => {
+  const explicitUrl = serverEnv.MONGODB_URL || serverEnv.MONGO_URL || serverEnv.MONGODB_URI || serverEnv.DB_URL;
+  if (explicitUrl) {
+    return explicitUrl;
   }
-  const sessionSecret = getDerivedKey(serverEnv.MASTER_KEY, "express_session_key");
+  if (serverEnv.DB_PORT) {
+    const host = serverEnv.DB_HOST ?? "localhost";
+    const dbName = serverEnv.APP_NAME ?? "rb";
+    return `mongodb://${host}:${serverEnv.DB_PORT}/${dbName}-sessions`;
+  }
+  return void 0;
+};
+const createMongoSessionStore = (serverEnv) => {
+  const mongoUrl = getMongoUrl(serverEnv);
+  if (!mongoUrl) {
+    throw new Error("Missing REDIS_URL and Mongo connection details (MONGODB_URL/MONGO_URL/MONGODB_URI/DB_PORT)");
+  }
+  console.log("Using MongoDB session store");
+  return MongoStore.create({
+    mongoUrl,
+    collectionName: "sessions",
+    ttl: SESSION_MAX_AGE_S
+  });
+};
+const createRedisSessionStore = async (redisUrl) => {
   const reconnectStrategy = (retries) => {
     console.log("redis_client::rb/server reconnectStrategy::retrying with arg", retries);
     if (retries < 5) {
@@ -70,7 +255,7 @@ const initServer = async (app, serverEnv) => {
     }
   };
   const redisClient = createClient({
-    url: serverEnv.REDIS_URL,
+    url: redisUrl,
     socket: {
       reconnectStrategy,
       connectTimeout: 1e4,
@@ -83,20 +268,44 @@ const initServer = async (app, serverEnv) => {
   redisClient.on("error", (error) => {
     console.log("session-storage::redis_client ERROR", error);
   });
-  redisClient.connect();
+  console.log("Using Redis session store");
+  await redisClient.connect();
+  return new RedisStore({
+    client: redisClient,
+    ttl: SESSION_MAX_AGE_S
+  });
+};
+const initServer = async (app, serverEnv) => {
+  await initApiClient({ app });
+  app.disable("x-powered-by");
+  app.set("trust proxy", true);
+  app.use(requestIp.mw());
+  app.use((req, res, next) => {
+    if (req.headers.host?.startsWith("www.")) {
+      const newHost = req.headers.host.replace("www.", "");
+      return res.redirect(301, `${req.protocol}://${newHost}${req.originalUrl}`);
+    }
+    next();
+  });
+  metricsIngestProxyMiddleware(app);
+  if (!serverEnv.MASTER_KEY) {
+    throw new Error("MASTER_KEY must be defined to derive the session secret");
+  }
+  const sessionSecret = getDerivedKey(serverEnv.MASTER_KEY, "express_session_key");
+  const redisUrl = serverEnv.REDIS_URL?.trim();
+  const store = redisUrl ? await createRedisSessionStore(redisUrl) : createMongoSessionStore(serverEnv);
   const sessionConfig = {
     name: "session",
-    store: new RedisStore({ client: redisClient }),
+    store,
     proxy: true,
     resave: false,
     saveUninitialized: false,
     secret: sessionSecret,
     cookie: {
-      maxAge: 1e3 * 3600 * 24 * 60
-      // 60 days
+      maxAge: SESSION_MAX_AGE_S * 1e3
     }
   };
-  if (isProduction) {
+  if (isProduction$1) {
     sessionConfig.cookie.secure = true;
   }
   app.use(session(sessionConfig));
@@ -122,8 +331,327 @@ async function hashPassword(password, salt) {
   });
   return derivedKey;
 }
+function createLocation(current, to, state = null, key) {
+  const location = {
+    pathname: current,
+    search: "",
+    hash: "",
+    ...typeof to === "string" ? parsePath(to) : to,
+    state,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: to && to.key || key
+  };
+  return location;
+}
+function getShortCircuitMatches(routes) {
+  const route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || {
+    id: "__shim-error-route__"
+  };
+  return {
+    matches: [
+      {
+        params: {},
+        pathname: "",
+        pathnameBase: "",
+        route
+      }
+    ],
+    route
+  };
+}
+async function applyRouteLoaders(req, dataRoutes) {
+  const baseUrl = `${req.protocol}://${req.get("host")}`;
+  const url = new URL(req.originalUrl, baseUrl);
+  const method = req.method;
+  const location = createLocation("", createPath(url), null, "default");
+  const baseContext = {
+    basename: "",
+    location,
+    loaderHeaders: {},
+    actionHeaders: {}
+  };
+  const matches = matchRoutes(dataRoutes, location) || [];
+  if (!matches) {
+    const error = {
+      status: 404,
+      message: `No route matches URL: ${req.originalUrl}`
+    };
+    const { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
+    return {
+      ...baseContext,
+      matches: notFoundMatches,
+      loaderData: {},
+      actionData: null,
+      errors: { [route.id]: error },
+      statusCode: 404
+    };
+  }
+  if (method !== "GET") {
+    return {
+      ...baseContext,
+      matches,
+      loaderData: {},
+      actionData: null,
+      errors: null,
+      statusCode: 200
+    };
+  }
+  const loaderPromisesResults = await Promise.allSettled(
+    matches.map(async (match) => {
+      const { route, params } = match;
+      if (!route.loader) return null;
+      try {
+        return {
+          id: route.id,
+          data: await route.loader({
+            params,
+            ctx: { req }
+          })
+        };
+      } catch (error) {
+        throw { id: route.id, reason: error };
+      }
+    })
+  );
+  const loaderData = {};
+  let errors = null;
+  for (const result of loaderPromisesResults) {
+    if (result.status === "fulfilled") {
+      if (result.value) {
+        loaderData[result.value.id] = result.value.data;
+      }
+    } else if (result.status === "rejected") {
+      const id = result.reason?.id;
+      if (!id) {
+        throw new Error(`missing route ID in error: ${result.reason}`);
+      }
+      if (!errors) {
+        errors = {};
+      }
+      errors[id] = result.reason;
+    }
+  }
+  return {
+    ...baseContext,
+    matches,
+    loaderData,
+    actionData: null,
+    errors,
+    statusCode: Object.keys(errors || {}).length > 0 ? 500 : 200
+  };
+}
+async function renderSSR(req, dataRoutes) {
+  let routerContext;
+  try {
+    routerContext = await applyRouteLoaders(req, dataRoutes);
+  } catch (err) {
+    console.log(err);
+    throw err;
+  }
+  if (routerContext.errors) {
+    console.log("SERVER ERRORS", routerContext.errors);
+  }
+  const router = createStaticRouter(dataRoutes, routerContext);
+  const element = /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsx(
+    StaticRouterProvider,
+    {
+      router,
+      context: routerContext
+    }
+  ) });
+  const isMatched = routerContext.matches.length > 0;
+  return { element, isMatched };
+}
+const ABORT_DELAY_MS = 1e4;
+const APP_HTML_PLACEHOLDER = "<!--app-html-->";
+const DEFAULT_SERVER_ERROR_MESSAGE = "We couldn't render this page on the server. Please refresh and try again.";
+const isProduction = env.NODE_ENV === "production";
+const templateHtml = isProduction ? readFileSync("./build/dist/client/src/client/index.html", "utf-8") : "";
+const formatErrorDetails = (error) => {
+  if (isProduction) return void 0;
+  if (!error) return void 0;
+  if (error instanceof Error) {
+    return error.stack || error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error, null, 2);
+  } catch {
+    return void 0;
+  }
+};
+const formatPlainErrorBody = (error) => {
+  if (isProduction) {
+    return "Server error";
+  }
+  if (error instanceof Error) {
+    return error.stack || error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error, null, 2);
+  } catch {
+    return "Unknown error";
+  }
+};
+const sendErrorResponse = ({
+  res,
+  htmlStart,
+  htmlEnd,
+  error,
+  status = 500,
+  title = "Server rendering error",
+  message = DEFAULT_SERVER_ERROR_MESSAGE,
+  errorExtraComponent
+}) => {
+  if (res.headersSent) return;
+  if (!htmlStart || !htmlEnd) {
+    res.status(status).end(formatPlainErrorBody(error));
+    return;
+  }
+  res.status(status);
+  res.set({ "Content-Type": "text/html" });
+  const details = formatErrorDetails(error);
+  const state = {
+    statusCode: status,
+    title,
+    message,
+    details
+  };
+  const markup = renderToStaticMarkup(
+    createElement(
+      StrictMode,
+      null,
+      createElement(SsrErrorFallback, {
+        state,
+        renderErrorExtra: (payload) => createElement(errorExtraComponent, { state: payload })
+      })
+    )
+  );
+  const serializedState = `<script>window.${SSR_ERROR_STATE_GLOBAL_KEY}=${serializeSsrErrorState({
+    ...state,
+    details: isProduction ? void 0 : details
+  })};<\/script>`;
+  res.end(`${htmlStart}${markup}${serializedState}${htmlEnd}`);
+};
+const ssrMiddleware = ({
+  viteInstance,
+  dataRoutes,
+  errorExtraComponent,
+  renderTemplateStart
+}) => async (req, res, next) => {
+  let template;
+  let htmlStart = null;
+  let htmlEnd = null;
+  let responseCommitted = false;
+  const finalizeWithErrorPage = (error, status = 500, message = DEFAULT_SERVER_ERROR_MESSAGE) => {
+    if (responseCommitted) return;
+    sendErrorResponse({
+      res,
+      htmlStart,
+      htmlEnd,
+      error,
+      status,
+      message,
+      errorExtraComponent
+    });
+    responseCommitted = true;
+  };
+  try {
+    const base = "/";
+    const url = req.originalUrl.replace(base, "");
+    if (isProduction) {
+      template = templateHtml;
+    } else {
+      template = await fs.readFile("./src/client/index.html", "utf-8");
+      template = await viteInstance.transformIndexHtml(url, template);
+    }
+    const placeholderIndex = template.indexOf(APP_HTML_PLACEHOLDER);
+    if (placeholderIndex === -1) {
+      throw new Error(`Template missing ${APP_HTML_PLACEHOLDER} placeholder`);
+    }
+    const templateStart = template.slice(0, placeholderIndex);
+    if (renderTemplateStart) {
+      htmlStart = await renderTemplateStart(req, templateStart);
+    } else {
+      htmlStart = templateStart;
+    }
+    htmlEnd = template.slice(placeholderIndex + APP_HTML_PLACEHOLDER.length);
+    const { element, isMatched } = await renderSSR(req, dataRoutes);
+    if (!isMatched) {
+      next();
+      return;
+    }
+    let didError = false;
+    const { pipe, abort } = renderToPipeableStream(
+      element,
+      {
+        onShellError(error) {
+          if (error instanceof Error) {
+            viteInstance?.ssrFixStacktrace(error);
+          }
+          console.error("SSR shell error", error);
+          finalizeWithErrorPage(error);
+          abort();
+        },
+        onError(error) {
+          didError = true;
+          if (error instanceof Error) {
+            viteInstance?.ssrFixStacktrace(error);
+          }
+          console.error("SSR rendering error", error);
+        },
+        onShellReady() {
+          if (responseCommitted) {
+            return;
+          }
+          if (!htmlStart || !htmlEnd) {
+            finalizeWithErrorPage();
+            return;
+          }
+          responseCommitted = true;
+          res.status(didError ? 500 : 200);
+          res.set({ "Content-Type": "text/html" });
+          const transformStream = new Transform({
+            transform(chunk, encoding, callback) {
+              res.write(chunk, encoding);
+              callback();
+            }
+          });
+          const start = htmlStart;
+          const end = htmlEnd;
+          res.write(start);
+          transformStream.on("finish", () => {
+            res.end(end);
+          });
+          pipe(transformStream);
+        }
+      }
+    );
+    setTimeout(() => {
+      abort();
+    }, ABORT_DELAY_MS);
+  } catch (err) {
+    if (err instanceof Error) {
+      viteInstance?.ssrFixStacktrace(err);
+      console.error("SSR middleware error:", err.message);
+      console.error(err.stack);
+    } else {
+      console.error("Unknown SSR middleware error", err);
+    }
+    finalizeWithErrorPage(err);
+  }
+};
 export {
   getDerivedKey,
   hashPassword,
-  initServer
+  initServer,
+  ssrMiddleware
 };

package/dist/initServer.d.ts

@@ -1,5 +1,7 @@
 import { Application } from 'express';
-export declare const initServer: (app: Application, serverEnv: {
+type ServerEnv = {
     [key: string]: string | undefined;
-}) => Promise<void>;
+};
+export declare const initServer: (app: Application, serverEnv: ServerEnv) => Promise<void>;
+export {};
 //# sourceMappingURL=initServer.d.ts.map

package/dist/initServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initServer.d.ts","sourceRoot":"","sources":["../src/initServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAsBrC,eAAO,MAAM,UAAU,GAAU,KAAK,WAAW,EAAE,WAAW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,kBA6ElG,CAAA"}
+{"version":3,"file":"initServer.d.ts","sourceRoot":"","sources":["../src/initServer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAsBrC,KAAK,SAAS,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAA;CAAE,CAAA;AA8EtD,eAAO,MAAM,UAAU,GAAU,KAAK,WAAW,EAAE,WAAW,SAAS,kBAmDtE,CAAA"}

package/dist/renderSSR.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+import { StaticHandler } from '../../router/src';
+import * as express from "express";
+export declare function renderSSR(req: express.Request, dataRoutes: StaticHandler["dataRoutes"]): Promise<{
+    element: ReactNode;
+    isMatched: boolean;
+}>;
+//# sourceMappingURL=renderSSR.d.ts.map

package/dist/renderSSR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderSSR.d.ts","sourceRoot":"","sources":["../src/renderSSR.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAA;AAClC,OAAO,EAAE,SAAS,EAAc,MAAM,OAAO,CAAA;AAC7C,OAAO,EAGL,aAAa,EACd,MAAM,iBAAiB,CAAA;AAOxB,wBAAsB,SAAS,CAC7B,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC,GACtC,OAAO,CAAC;IAAC,OAAO,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC,CAAC,CA+BnD"}

package/dist/ssrMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { StaticHandler } from '../../router/src';
+import { createServer } from 'vite';
+import { ReactNode } from 'react';
+import { NextFunction, Request, Response } from 'express';
+type ViteDevServer = Awaited<ReturnType<typeof createServer>>;
+export declare const ssrMiddleware: ({ viteInstance, dataRoutes, errorExtraComponent, renderTemplateStart, }: {
+    viteInstance: ViteDevServer;
+    dataRoutes: StaticHandler["dataRoutes"];
+    errorExtraComponent: ReactNode;
+    renderTemplateStart?: (req: Request, templateStart: string) => Promise<string>;
+}) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
+export {};
+//# sourceMappingURL=ssrMiddleware.d.ts.map

package/dist/ssrMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrMiddleware.d.ts","sourceRoot":"","sources":["../src/ssrMiddleware.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAEjE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAKzD,KAAK,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC;AAuG9D,eAAO,MAAM,aAAa,GAAI,yEAK3B;IACD,YAAY,EAAE,aAAa,CAAC;IAC5B,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IACxC,mBAAmB,EAAE,SAAS,CAAC;IAC/B,mBAAmB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAChF,MAAW,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,kBAyH1D,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/server",
-  "version": "0.441.0",
+  "version": "0.443.0",
   "type": "module",
   "files": [
     "dist"
@@ -44,11 +44,13 @@
     }
   },
   "dependencies": {
+    "connect-mongo": "6.0.0",
     "connect-redis": "9.0.0",
     "express-session": "1.18.2",
     "http-proxy-middleware": "3.0.5",
-    "redis": "5.8.2",
-    "request-ip": "3.3.0"
+    "redis": "5.10.0"
   },
-  "devDependencies": {}
+  "devDependencies": {
+    "request-ip": "3.3.0"
+  }
 }