@lwrjs/core 0.9.0-alpha.9 → 0.9.1

package/build/cjs/middleware/redirects/unsigned-module-redirect.cjs

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+
+// packages/@lwrjs/core/src/middleware/redirects/unsigned-module-redirect.ts
+__markAsModule(exports);
+__export(exports, {
+  createUnsignedBundleRedirect: () => createUnsignedBundleRedirect,
+  createUnsignedModuleRedirect: () => createUnsignedModuleRedirect
+});
+var HEADER_LOCATION = "Location";
+var STATUS_FOUND = 302;
+function createUnsignedModuleRedirect(moduleRegistry) {
+  return async (req, res, moduleId, runtimeEnvironment, runtimeParams) => {
+    const jsonQuery = getJsonQualifier(req, runtimeEnvironment);
+    const {moduleEntry, ownHash} = await moduleRegistry.getModule(moduleId);
+    const uri = await moduleRegistry.resolveModuleUri({...moduleId, version: moduleEntry.version}, runtimeEnvironment, runtimeParams, ownHash);
+    sendRedirect(res, `${uri}${jsonQuery}`);
+  };
+}
+function createUnsignedBundleRedirect(moduleBundler) {
+  return async (req, res, moduleId, runtimeEnvironment, runtimeParams) => {
+    const jsonQuery = getJsonQualifier(req, runtimeEnvironment);
+    const uri = await moduleBundler.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
+    sendRedirect(res, `${uri}${jsonQuery}`);
+  };
+}
+function getJsonQualifier(req, runtimeEnvironment) {
+  return req.isJsonRequest() ? `${runtimeEnvironment.debug ? "&" : "?"}json` : "";
+}
+function sendRedirect(res, url) {
+  res.setHeader(HEADER_LOCATION, url);
+  res.sendStatus(STATUS_FOUND);
+}

package/build/cjs/middleware/resource-middleware.cjs

@@ -0,0 +1,64 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/core/src/middleware/resource-middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  resourceMiddleware: () => resourceMiddleware
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_identity = __toModule(require("./utils/identity.cjs"));
+var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
+function createResourceMiddleware(context) {
+  const {resourceRegistry} = context;
+  return async (req, res) => {
+    if (!req.validateEnvironmentRequest(context.appConfig)) {
+      res.status(400).send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+      return;
+    }
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {resourceId} = (0, import_identity.getResourceIdentity)(req);
+    const resource = await resourceRegistry.getResource(resourceId, runtimeEnvironment, runtimeParams);
+    if (req.isSiteGeneration()) {
+      res.setSiteGenerationMetadata({resource});
+    }
+    if (resource && resource.content) {
+      const type = resource.type === "text/css" ? resource.type : "application/javascript";
+      res.status(200).type(type).send(resource.content);
+      return;
+    }
+    if (resource && resource.stream) {
+      res.status(200).type(resource.type).stream(resource.stream());
+      return;
+    }
+    res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.RESOURCE(resourceId.specifier).message);
+  };
+}
+function resourceMiddleware(app, context) {
+  app.get([
+    `/:apiVersion/resource/:format/l/:locale/e/:environment/:specifier/:prettyUrl?`,
+    `/:apiVersion/resource/:format/l/:locale/:specifier/:prettyUrl?`,
+    `/:apiVersion/resource/:format/e/:environment/:specifier/:prettyUrl?`,
+    `/:apiVersion/resource/:format/:specifier/:prettyUrl?`
+  ], (0, import_error_handling.handleErrors)(createResourceMiddleware(context)));
+}

package/build/cjs/{context/global-data.cjs → middleware/utils/error-handling.cjs}

@@ -21,34 +21,36 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/core/src/context/global-data.ts
+// packages/@lwrjs/core/src/middleware/utils/error-handling.ts
 __markAsModule(exports);
 __export(exports, {
-  getGlobalData: () => getGlobalData
+  handleErrors: () => handleErrors
 });
-var import_fs = __toModule(require("fs"));
-var import_path = __toModule(require("path"));
-function recursiveJsonCollector(resources, currentPath, collector) {
-  for (const resource of resources) {
-    const resourcePath = import_path.default.join(currentPath, resource);
-    if (resource.endsWith(".json")) {
-      const resourceName = import_path.default.basename(resource, ".json");
-      const jsonSource = JSON.parse(import_fs.default.readFileSync(resourcePath, "utf-8"));
-      collector[resourceName] = jsonSource;
-    } else if (import_fs.default.statSync(resourcePath).isDirectory()) {
-      const dirContentList = import_fs.default.readdirSync(resourcePath);
-      collector[resource] = recursiveJsonCollector(dirContentList, resourcePath, {});
-    }
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+function createReturnStatus(error, url) {
+  if (error instanceof import_diagnostics.LwrUnresolvableError && error.diagnostics[0].description.category === "lwrUnresolvable/invalid") {
+    return {status: 400, message: error.message};
   }
-  return collector;
-}
-function getGlobalData(globalDataDir, defaultData = {}) {
-  if (!import_fs.default.existsSync(globalDataDir) || !import_fs.default.statSync(globalDataDir).isDirectory()) {
-    return defaultData;
+  if (error instanceof import_diagnostics.LwrUnresolvableError) {
+    return {status: 404, message: error.message};
   }
-  const dirContentList = import_fs.default.readdirSync(globalDataDir);
-  return {
-    ...recursiveJsonCollector(dirContentList, globalDataDir, {}),
-    ...defaultData
+  return {status: 500, message: import_diagnostics.descriptions.UNRESOLVABLE.SERVER_ERROR(url).message};
+}
+function handleErrors(middleware) {
+  return async (req, res, next) => {
+    try {
+      await middleware(req, res, next);
+    } catch (err) {
+      if (err instanceof import_diagnostics.DiagnosticsError) {
+        console.error("LWR Diagnostic Error: " + err.message);
+        console.error(err.diagnostics);
+        console.error(err.stack);
+      } else {
+        console.error(err);
+      }
+      const {status, message} = createReturnStatus(err, req.originalUrl);
+      res.status(status);
+      res.send(message);
+    }
   };
 }

package/build/cjs/middleware/utils/identity.cjs

@@ -0,0 +1,92 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/core/src/middleware/utils/identity.ts
+__markAsModule(exports);
+__export(exports, {
+  getAssetIdentity: () => getAssetIdentity,
+  getMappingIdentity: () => getMappingIdentity,
+  getModuleIdentity: () => getModuleIdentity,
+  getResourceIdentity: () => getResourceIdentity
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+function validateSpecifier(specifer) {
+  return specifer.indexOf("../") < 0;
+}
+function getModuleIdentity(req, importer) {
+  const {specifier, signature} = req.params;
+  if (validateSpecifier(specifier) === false) {
+    throw (0, import_diagnostics.createSingleDiagnosticError)({
+      description: import_diagnostics.descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier)
+    }, import_diagnostics.LwrUnresolvableError);
+  }
+  const moduleId = (0, import_shared_utils.explodeSpecifier)(specifier);
+  return {
+    moduleId: {
+      ...moduleId,
+      importer
+    },
+    signature
+  };
+}
+function getMappingIdentity(req) {
+  const {specifiers} = req.params;
+  const moduleIds = (0, import_shared_utils.explodeSpecifiers)(specifiers).map((obj) => ({
+    ...obj,
+    importer: req.query.importer
+  }));
+  return {
+    moduleIds
+  };
+}
+function getResourceIdentity(req) {
+  const {specifier, signature = import_shared_utils.LATEST_SIGNATURE} = req.params;
+  if (validateSpecifier(specifier) === false) {
+    throw (0, import_diagnostics.createSingleDiagnosticError)({
+      description: import_diagnostics.descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier)
+    }, import_diagnostics.LwrUnresolvableError);
+  }
+  const resourceId = (0, import_shared_utils.explodeSpecifier)(specifier);
+  return {
+    resourceId,
+    signature
+  };
+}
+function getAssetIdentity(req) {
+  const {signature, immutable, assetType: type} = req.params;
+  const specifier = signature && type ? "/" + req.params[0] : req.originalUrl.split("?")[0];
+  if (validateSpecifier(specifier) === false) {
+    throw (0, import_diagnostics.createSingleDiagnosticError)({
+      description: import_diagnostics.descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier)
+    }, import_diagnostics.LwrUnresolvableError);
+  }
+  return {
+    immutable,
+    assetId: {
+      specifier,
+      type
+    },
+    signature: signature || import_shared_utils.LATEST_SIGNATURE
+  };
+}

package/build/cjs/{context/services.cjs → middleware/utils/metadata.cjs}

@@ -21,30 +21,29 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/core/src/context/services.ts
+// packages/@lwrjs/core/src/middleware/utils/metadata.ts
 __markAsModule(exports);
 __export(exports, {
-  getServices: () => getServices
+  normalizeResolvedUris: () => normalizeResolvedUris
 });
-var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-async function getServiceModule(path, {cacheDir, rootDir}) {
-  try {
-    if (path.endsWith(".ts")) {
-      const fullPath = (0, import_shared_utils.resolveFileExtension)(path);
-      path = await (0, import_shared_utils.transpileTs)(fullPath, {rootDir, cacheDir: import_path.default.join(cacheDir, "services")});
+async function normalizeResolvedUris(bundleDefinition, runtimeEnvironment, runtimeParams, moduleBundler, moduleRegistry) {
+  const resolvedUris = [];
+  if (bundleDefinition.bundleRecord.imports) {
+    for (const theImport of bundleDefinition.bundleRecord.imports) {
+      const childSpecifier = theImport.specifier;
+      const id = await (0, import_shared_utils.getVersionedModuleId)(childSpecifier, moduleRegistry);
+      const uri = await moduleBundler.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
+      resolvedUris.push(uri);
     }
-    const moduleEntry = await Promise.resolve().then(() => __toModule(require(path)));
-    return moduleEntry.default || moduleEntry;
-  } catch (err) {
-    console.log(err);
-    throw new Error(`Unable to get Service: ${path}`);
   }
-}
-async function getServices(services, providerContext, lwrConfig) {
-  return Promise.all(services.map(async (serviceEntry) => {
-    const [serviceName, serviceConfig = {}] = Array.isArray(serviceEntry) ? serviceEntry : [serviceEntry];
-    const ServiceCtor = await getServiceModule(serviceName, lwrConfig);
-    return new ServiceCtor(serviceConfig, providerContext);
-  }));
+  if (bundleDefinition.bundleRecord.dynamicImports) {
+    for (const theImport of bundleDefinition.bundleRecord.dynamicImports) {
+      const childSpecifier = theImport.specifier;
+      const id = await (0, import_shared_utils.getVersionedModuleId)(childSpecifier, moduleRegistry);
+      const uri = await moduleBundler.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
+      resolvedUris.push(uri);
+    }
+  }
+  return resolvedUris;
 }

package/build/cjs/{middlewares/utils.cjs → middleware/utils/request.cjs}

@@ -21,14 +21,21 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/core/src/middlewares/utils.ts
+// packages/@lwrjs/core/src/middleware/utils/request.ts
 __markAsModule(exports);
 __export(exports, {
-  getRequestProperties: () => getRequestProperties,
-  isSupportedEnvironment: () => isSupportedEnvironment
+  getRequestImporter: () => getRequestImporter,
+  getRequestProperties: () => getRequestProperties
 });
-var import_path_to_regexp = __toModule(require("path-to-regexp"));
 var import_qs = __toModule(require("qs"));
+var import_path_to_regexp = __toModule(require("path-to-regexp"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+function decodeParam(val) {
+  if (typeof val !== "string" || val.length === 0) {
+    return val;
+  }
+  return decodeURIComponent(val);
+}
 function getRequestProperties(pattern, req) {
   const {url = "/"} = req;
   const [pathname, search] = url.split("?");
@@ -41,7 +48,7 @@ function getRequestProperties(pattern, req) {
     for (let i = 1; i < matched.length; i++) {
       const key = keys[i - 1];
       const prop = key.name;
-      const val = decode_param(matched[i]);
+      const val = decodeParam(matched[i]);
       if (val !== void 0 || !Object.hasOwnProperty.call(params, prop)) {
         params[prop] = val;
       }
@@ -54,15 +61,9 @@ function getRequestProperties(pattern, req) {
   }
   return;
 }
-function isSupportedEnvironment(environmentConfig, targetEnvironment) {
-  if (!!targetEnvironment && targetEnvironment !== environmentConfig?.default && !environmentConfig?.supported?.includes(targetEnvironment)) {
-    return false;
-  }
-  return true;
-}
-function decode_param(val) {
-  if (typeof val !== "string" || val.length === 0) {
-    return val;
-  }
-  return decodeURIComponent(val);
+async function getRequestImporter(req, moduleRegistry) {
+  const importerSpecifier = req.query.importer;
+  const importerModuleId = (0, import_shared_utils.explodeSpecifier)(importerSpecifier);
+  const {entry} = await moduleRegistry.getModuleEntry(importerModuleId);
+  return entry;
 }

package/build/cjs/middleware/view-middleware.cjs

@@ -0,0 +1,151 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/core/src/middleware/view-middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  viewMiddleware: () => viewMiddleware
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_router = __toModule(require("@lwrjs/router"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
+var import_view_registry = __toModule(require("@lwrjs/view-registry"));
+var CANONICAL_VIEW_ROUTES = [
+  `/:apiVersion/application/:format/l/:locale/ai/:appId`,
+  `/:apiVersion/application/:format/l/:locale/e/:environment/ai/:appId`,
+  `/:apiVersion/application/:format/ai/:appId`,
+  `/:apiVersion/application/:format/e/:environment/ai/:appId`
+];
+function createViewMiddleware(route, errorRoutes, context, viewHandler) {
+  const errorRoute = errorRoutes.find((route2) => route2.status === 500);
+  return async (req, res) => {
+    if (!req.validateEnvironmentRequest(context.appConfig)) {
+      res.status(400);
+      res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+      return;
+    }
+    if (!req.validateJsonRequest()) {
+      res.status(400);
+      res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
+      return;
+    }
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {environment: environmentConfig} = context.appConfig;
+    if (!runtimeParams.environment && environmentConfig?.default) {
+      runtimeParams.environment = environmentConfig.default;
+    }
+    const viewRequest = {
+      url: req.originalUrl,
+      params: req.params,
+      query: req.query,
+      requestPath: req.path
+    };
+    const resolve = req.isJsonRequest() ? viewHandler.getViewJson : viewHandler.getViewContent;
+    let viewResponse;
+    let resolvedRoute;
+    try {
+      viewResponse = await resolve.call(viewHandler, viewRequest, route, runtimeEnvironment, runtimeParams);
+      resolvedRoute = route;
+    } catch (err) {
+      if (!errorRoute) {
+        throw err;
+      }
+      viewResponse = await resolve.call(viewHandler, viewRequest, errorRoute, runtimeEnvironment, runtimeParams);
+      resolvedRoute = errorRoute;
+    }
+    if (req.isSiteGeneration()) {
+      res.setSiteGenerationMetadata(viewResponse.metadata);
+    }
+    res.type("text/html");
+    if (viewResponse.headers) {
+      res.set(viewResponse.headers);
+    }
+    const cacheTtl = (0, import_shared_utils.shortestTtl)(viewResponse.cache?.ttl, resolvedRoute.cache?.ttl);
+    if (cacheTtl) {
+      res.setHeader("cache-control", `public, max-age=${cacheTtl}`);
+    }
+    const status = resolvedRoute.status || viewResponse.status || 200;
+    res.status(status);
+    res.send(viewResponse.body);
+  };
+}
+function createConfigMiddleware(routes, context, viewHandler) {
+  return async (req, res) => {
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {appId, encodedViewPath} = req.params;
+    const route = routes.find((route2) => route2.id === appId);
+    if (!route) {
+      res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.APP_CONFIG(appId).message);
+      return;
+    }
+    const url = (0, import_shared_utils.decodeViewPath)(encodedViewPath);
+    const requestPath = route.path;
+    const params = (0, import_shared_utils.extractRequestParams)(requestPath, url, req.params);
+    const viewRequest = {
+      url,
+      params,
+      query: req.query,
+      requestPath
+    };
+    const viewResponse = await viewHandler.getViewConfiguration(viewRequest, route, runtimeEnvironment, runtimeParams);
+    if (!viewResponse) {
+      res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.VIEW_CONFIG(url).message);
+      return;
+    }
+    const cacheTtl = (0, import_shared_utils.shortestTtl)(viewResponse.cache?.ttl, route.cache?.ttl);
+    if (cacheTtl) {
+      res.setHeader("cache-control", `public, max-age=${cacheTtl}`);
+    }
+    res.status(200);
+    res.type("application/javascript");
+    res.status(viewResponse.status || 200);
+    res.send(viewResponse.body);
+  };
+}
+function createNotFoundMiddleware(errorRoutes, context, viewHandler) {
+  const notFoundRoute = errorRoutes.find((route) => route.status === 404);
+  if (notFoundRoute) {
+    return createViewMiddleware(notFoundRoute, errorRoutes, context, viewHandler);
+  }
+  return (req, res) => {
+    res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.VIEW(req.originalUrl).message);
+  };
+}
+function viewMiddleware(app, context) {
+  const {appConfig, viewRegistry, moduleRegistry, routeHandlers} = context;
+  const {routes, errorRoutes} = appConfig;
+  const viewHandler = new import_view_registry.LwrViewHandler({viewRegistry, moduleRegistry, routeHandlers}, appConfig);
+  for (const route of routes) {
+    const paths = [route.path];
+    const subRoutes = route.subRoutes && (0, import_router.getClientRoutes)(route.subRoutes);
+    if (subRoutes) {
+      const prefix = route.path === "/" ? "" : route.path;
+      subRoutes.routes.forEach((subRoute) => subRoute.uri !== route.path && paths.push(`${prefix}${subRoute.uri}`));
+    }
+    paths.forEach((routePath) => paths.push(...CANONICAL_VIEW_ROUTES.map((viewRoute) => viewRoute + routePath)));
+    app.get(paths, (0, import_error_handling.handleErrors)(createViewMiddleware(route, errorRoutes, context, viewHandler)));
+  }
+  app.get((0, import_shared_utils.getClientBootstrapConfigurationRoutes)(), (0, import_error_handling.handleErrors)(createConfigMiddleware(routes, context, viewHandler)));
+  app.get("/" + app.getRegexWildcard(), (0, import_error_handling.handleErrors)(createNotFoundMiddleware(errorRoutes, context, viewHandler)));
+}

package/build/cjs/middleware.cjs

@@ -24,13 +24,20 @@ var __toModule = (module2) => {
 // packages/@lwrjs/core/src/middleware.ts
 __markAsModule(exports);
 __export(exports, {
-  attachLwrMiddleware: () => attachLwrMiddleware
+  assetMiddleware: () => import_asset_middleware.assetMiddleware,
+  bundleMiddleware: () => import_bundle_middleware.bundleMiddleware,
+  hmrMiddleware: () => import_hmr_middleware.hmrMiddleware,
+  localeMiddleware: () => import_locale_middleware.localeMiddleware,
+  mappingMiddleware: () => import_mapping_middleware.mappingMiddleware,
+  moduleMiddleware: () => import_module_middleware.moduleMiddleware,
+  resourceMiddleware: () => import_resource_middleware.resourceMiddleware,
+  viewMiddleware: () => import_view_middleware.viewMiddleware
 });
-var import_locale_middleware = __toModule(require("./middlewares/locale-middleware.cjs"));
-var import_ui_middleware = __toModule(require("./middlewares/ui-middleware.cjs"));
-var import_api_middleware = __toModule(require("./middlewares/api-middleware.cjs"));
-function attachLwrMiddleware(app, context) {
-  (0, import_locale_middleware.default)(app, context);
-  (0, import_api_middleware.default)(app, context);
-  (0, import_ui_middleware.default)(app, context);
-}
+var import_locale_middleware = __toModule(require("./middleware/locale-middleware.cjs"));
+var import_hmr_middleware = __toModule(require("./middleware/hmr-middleware.cjs"));
+var import_module_middleware = __toModule(require("./middleware/module-middleware.cjs"));
+var import_bundle_middleware = __toModule(require("./middleware/bundle-middleware.cjs"));
+var import_mapping_middleware = __toModule(require("./middleware/mapping-middleware.cjs"));
+var import_asset_middleware = __toModule(require("./middleware/asset-middleware.cjs"));
+var import_view_middleware = __toModule(require("./middleware/view-middleware.cjs"));
+var import_resource_middleware = __toModule(require("./middleware/resource-middleware.cjs"));

package/build/cjs/tools/server-warmup.cjs

@@ -36,17 +36,10 @@ async function warmupServer(config, internalRequestKey) {
     import_shared_utils.logger.setOptions({dedupe: new Set([import_shared_utils.WARN])});
   }
   import_shared_utils.logger.info("[Server Warmup] starting");
-  const {routes, staticSiteGenerator, port, apiVersion, basePath, lwrVersion, serverMode} = config;
+  const {routes, staticSiteGenerator, port, basePath} = config;
   staticSiteGenerator.outputDir = import_dir.skipDirCreation;
   const urlRewriteMap = new Map();
-  const runtimeEnvironment = {
-    ...(0, import_config.explodeMode)(serverMode),
-    apiVersion,
-    basePath,
-    lwrVersion,
-    debug: false,
-    serverMode
-  };
+  const runtimeEnvironment = (0, import_config.getRuntimeEnvironment)(config);
   await new import_static_generation.default().generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, new import_network_dispatcher.default(port, internalRequestKey), staticSiteGenerator.outputDir, urlRewriteMap);
   import_shared_utils.logger.info("[Server Warmup] complete");
 }