@lwrjs/core 0.11.0-alpha.0 → 0.11.0-alpha.10

package/build/cjs/context/provider.cjs

@@ -31,6 +31,7 @@ function createProviderContext(serverContext) {
   const {
     assets,
     cacheDir,
+    i18n,
     lwc: {modules = []},
     routes,
     errorRoutes,
@@ -67,6 +68,7 @@ function createProviderContext(serverContext) {
     config: (0, import_shared_utils.deepFreeze)({
       assets,
       cacheDir,
+      i18n,
       modules,
       routes,
       errorRoutes,

package/build/cjs/index.cjs

@@ -37,6 +37,7 @@ var import_static_generation = __toModule(require("./tools/static-generation.cjs
 var import_server_warmup = __toModule(require("./tools/server-warmup.cjs"));
 var import_server2 = __toModule(require("./context/server.cjs"));
 var import_provider = __toModule(require("./context/provider.cjs"));
+var import_request_processor_middleware = __toModule(require("./middleware/request-processor-middleware.cjs"));
 var import_locale_middleware = __toModule(require("./middleware/locale-middleware.cjs"));
 var import_module_middleware = __toModule(require("./middleware/module-middleware.cjs"));
 var import_bundle_middleware = __toModule(require("./middleware/bundle-middleware.cjs"));
@@ -47,7 +48,7 @@ var import_resource_middleware = __toModule(require("./middleware/resource-middl
 var import_hmr_middleware = __toModule(require("./middleware/hmr-middleware.cjs"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 function initMiddleware(app, server, serverContext) {
-  app.useCompression();
+  (0, import_request_processor_middleware.requestProcessorMiddleware)(app, serverContext);
   (0, import_locale_middleware.localeMiddleware)(app, serverContext);
   (0, import_module_middleware.moduleMiddleware)(app, serverContext);
   (0, import_bundle_middleware.bundleMiddleware)(app, serverContext);
@@ -69,7 +70,7 @@ async function initContext(appConfig, runtimeEnvironment, globalData) {
     const skipValidation = true;
     await (0, import_config.executeConfigHooks)(hooks, appConfig, runtimeEnvironment, globalData, skipValidation);
     (0, import_config.executeInstrumentationHooks)(hooks);
-    (0, import_config.executeStartHooks)(hooks, appConfig);
+    (0, import_config.executeStartHooks)(hooks, appConfig, runtimeEnvironment);
   }
   const services = await (0, import_modules.loadServices)(appConfig);
   const serverContext = (0, import_instrumentation.getTracer)().trace({name: import_instrumentation.CoreSpan.CreateServerContext}, () => (0, import_server2.createServerContext)(appConfig, runtimeEnvironment, globalData));
@@ -191,7 +192,7 @@ async function generateStaticSite(config) {
   config.serverType = "fs";
   const {serverMode} = config;
   if (serverMode === "dev" || serverMode === "compat") {
-    import_shared_utils.logger.warn("static generation in `dev` or `compat` mode is currently not fully supported");
+    import_diagnostics.logger.warn("static generation in `dev` or `compat` mode is currently not fully supported");
   }
   const lwrApp = createServer(config);
   overrideConfigAsSrc(lwrApp);

package/build/cjs/middleware/asset-middleware.cjs

@@ -32,11 +32,12 @@ var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 function createAssetMiddleware(context) {
   const {
+    appConfig: {i18n},
     assetRegistry,
     runtimeEnvironment: {basePath}
   } = context;
   return async (req, res, next) => {
-    const {runtimeEnvironment} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment} = req.getRuntimeContext(context.runtimeEnvironment, i18n);
     const {assetId, immutable, signature} = (0, import_identity.getAssetIdentity)(req);
     if (basePath && !assetId.specifier.startsWith(basePath)) {
       assetId.specifier = import_path.default.join(basePath, assetId.specifier);

package/build/cjs/middleware/bundle-middleware.cjs

@@ -34,10 +34,16 @@ var import_metadata = __toModule(require("./utils/metadata.cjs"));
 var import_unsigned_module_redirect = __toModule(require("./redirects/unsigned-module-redirect.cjs"));
 var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
 function createBundleMiddleware(context) {
-  const {moduleRegistry, moduleBundler} = context;
+  const {
+    appConfig,
+    appConfig: {i18n},
+    moduleRegistry,
+    moduleBundler,
+    runtimeEnvironment: defaultRuntimeEnvironment
+  } = context;
   const unsignedBundleRedirect = (0, import_unsigned_module_redirect.createUnsignedBundleRedirect)(moduleBundler);
   return async (req, res) => {
-    if (!req.validateEnvironmentRequest(context.appConfig)) {
+    if (!req.validateEnvironmentRequest(appConfig)) {
       res.status(400);
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
       return;
@@ -47,8 +53,8 @@ function createBundleMiddleware(context) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
-    const importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry) : void 0;
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment, i18n);
+    const importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry, runtimeParams) : void 0;
     const {moduleId, signature} = (0, import_identity.getModuleIdentity)(req, importer);
     if (moduleId.importer || !signature) {
       await unsignedBundleRedirect(req, res, moduleId, runtimeEnvironment, runtimeParams);
@@ -69,14 +75,19 @@ function createBundleMiddleware(context) {
   };
 }
 function createSourceMapMiddleware(context) {
-  const {moduleBundler} = context;
+  const {
+    appConfig,
+    appConfig: {i18n},
+    moduleBundler,
+    runtimeEnvironment: defaultRuntimeEnvironment
+  } = context;
   return async (req, res) => {
-    if (!req.validateEnvironmentRequest(context.appConfig)) {
+    if (!req.validateEnvironmentRequest(appConfig)) {
       res.status(400);
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
       return;
     }
-    const {runtimeEnvironment} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment} = req.getRuntimeContext(defaultRuntimeEnvironment, i18n);
     const {moduleId, signature} = (0, import_identity.getModuleIdentity)(req);
     const bundleDef = await moduleBundler.getModuleBundle(moduleId, runtimeEnvironment);
     if (signature !== import_shared_utils.LATEST_SIGNATURE) {

package/build/cjs/middleware/hmr-middleware.cjs

@@ -27,6 +27,7 @@ __export(exports, {
   hmrMiddleware: () => hmrMiddleware
 });
 var import_ws = __toModule(require("ws"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_request = __toModule(require("./utils/request.cjs"));
 var hmr;
@@ -60,9 +61,9 @@ var Hmr = class {
     });
     wss.on("error", (error) => {
       if (error.code === "EADDRINUSE") {
-        console.error(`HMR Socket Server: Port ${this.context.appConfig.port} already in use.`);
+        import_diagnostics.logger.error(`HMR Socket Server: Port ${this.context.appConfig.port} already in use.`);
       } else {
-        console.error(error);
+        import_diagnostics.logger.error(error);
       }
     });
   }
@@ -78,7 +79,7 @@ var Hmr = class {
       runtimeParams
     } = moduleDefinition;
     const {format, debug, compat} = runtimeEnvironment;
-    console.log("Recompiled module:", specifier, signature);
+    import_diagnostics.logger.info(`Recompiled module: ${specifier}, ${signature}`);
     const moduleId = {
       specifier,
       namespace,
@@ -106,7 +107,7 @@ var Hmr = class {
     }
   }
   updateTemplateOnClients(compiledView) {
-    console.log("Recompiled view source:", compiledView.viewId);
+    import_diagnostics.logger.info("Recompiled view source", compiledView.viewId);
     const {contentTemplate} = compiledView.viewId;
     if (this.connectedClients && contentTemplate) {
       for (const ws of this.connectedClients.keys()) {
@@ -121,7 +122,7 @@ var Hmr = class {
   }
   updateAssetOnClients(asset) {
     const assetId = asset.entry;
-    console.log("Updated asset:", assetId);
+    import_diagnostics.logger.info(`Updated asset: ${assetId}`);
     if (this.connectedClients) {
       for (const ws of this.connectedClients.keys()) {
         ws.send(JSON.stringify({

package/build/cjs/middleware/locale-middleware.cjs

@@ -12,9 +12,9 @@ __export(exports, {
 });
 function localeMiddleware(app, context) {
   const {defaultLocale} = context.runtimeEnvironment;
-  app.use(async (req, res, next) => {
+  app.use(async (req, _res, next) => {
     const langs = req.acceptsLanguages();
-    req.locale = langs?.length > 0 ? langs[0] : defaultLocale;
+    req.locale = langs?.length > 0 && langs[0] != "*" ? langs[0] : defaultLocale;
     await next();
   });
 }

package/build/cjs/middleware/mapping-middleware.cjs

@@ -31,14 +31,20 @@ 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 createMappingMiddleware(context) {
-  const {moduleBundler, moduleRegistry} = context;
+  const {
+    appConfig,
+    appConfig: {i18n},
+    moduleBundler,
+    moduleRegistry,
+    runtimeEnvironment: defaultRuntimeEnvironment
+  } = context;
   return async (req, res) => {
-    if (!req.validateEnvironmentRequest(context.appConfig)) {
+    if (!req.validateEnvironmentRequest(appConfig)) {
       res.status(400);
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment, i18n);
     const {moduleIds} = (0, import_identity.getMappingIdentity)(req);
     const importMetadata = await (0, import_shared_utils.getImportMetadataMappings)(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
     if (req.isSiteGeneration()) {

package/build/cjs/middleware/module-middleware.cjs

@@ -33,10 +33,15 @@ var import_identity = __toModule(require("./utils/identity.cjs"));
 var import_unsigned_module_redirect = __toModule(require("./redirects/unsigned-module-redirect.cjs"));
 var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
 function createModuleMiddleware(context) {
-  const {moduleRegistry} = context;
+  const {
+    appConfig,
+    appConfig: {i18n},
+    moduleRegistry,
+    runtimeEnvironment: defaultRuntimeEnvironment
+  } = context;
   const unsignedRedirect = (0, import_unsigned_module_redirect.createUnsignedModuleRedirect)(moduleRegistry);
   return async (req, res) => {
-    if (!req.validateEnvironmentRequest(context.appConfig)) {
+    if (!req.validateEnvironmentRequest(appConfig)) {
       res.status(400);
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
       return;
@@ -46,8 +51,8 @@ function createModuleMiddleware(context) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
-    const importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry) : void 0;
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment, i18n);
+    const importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry, runtimeParams) : void 0;
     const {moduleId, signature} = (0, import_identity.getModuleIdentity)(req, importer);
     if (moduleId.importer || !signature) {
       await unsignedRedirect(req, res, moduleId, runtimeEnvironment, runtimeParams);

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

@@ -16,7 +16,7 @@ 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 {moduleEntry, ownHash} = await moduleRegistry.getModule(moduleId, runtimeParams);
     const uri = await moduleRegistry.resolveModuleUri({...moduleId, version: moduleEntry.version}, runtimeEnvironment, runtimeParams, ownHash);
     sendRedirect(res, `${uri}${jsonQuery}`);
   };

package/build/cjs/middleware/request-processor-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/request-processor-middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  requestProcessorMiddleware: () => requestProcessorMiddleware
+});
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var MRT_REQUEST_CLASS = "X-Mobify-Request-Class";
+var MRT_REQUEST_CLASS_KEY = MRT_REQUEST_CLASS.toLowerCase();
+function requestProcessorMiddleware(app, context) {
+  const {basePath} = context.runtimeEnvironment;
+  app.use(async (req, _res, next) => {
+    let requestClass;
+    if (req.headers) {
+      if (import_diagnostics.logger.currentLevel === "debug" || import_diagnostics.logger.currentLevel == "verbose") {
+        for (const headerName in req.headers) {
+          import_diagnostics.logger.debug(`[request-processor-middleware] Header ${headerName}: ${req.headers[headerName]}`);
+        }
+      }
+      requestClass = req.headers[MRT_REQUEST_CLASS_KEY];
+    }
+    if (req.headers && typeof requestClass === "string") {
+      const parsedRequestClass = parseRequestClass(requestClass);
+      import_diagnostics.logger.debug(`[request-processor-middleware] parsedRequestClass?.basePath: ${parsedRequestClass?.basePath}`);
+      const pathValue = parsedRequestClass?.basePath || basePath || "";
+      req.basePath = pathValue === "" || pathValue.indexOf("/") === 0 ? pathValue : `/${pathValue}`;
+    } else {
+      import_diagnostics.logger.debug(`[request-processor-middleware] ${MRT_REQUEST_CLASS_KEY} ignored ${req.headers ? req.headers[MRT_REQUEST_CLASS_KEY] : "no-headers"}`);
+      req.basePath = basePath;
+    }
+    await next();
+  });
+}
+function parseRequestClass(requestClass) {
+  const keyValuePairs = requestClass.split(";");
+  const parsed = {};
+  for (const pair of keyValuePairs) {
+    const [key, value] = pair.split("=");
+    parsed[key] = value;
+  }
+  return parsed;
+}

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

@@ -30,13 +30,18 @@ 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;
+  const {
+    appConfig,
+    appConfig: {i18n},
+    resourceRegistry,
+    runtimeEnvironment: defaultRuntimeEnvironment
+  } = context;
   return async (req, res) => {
-    if (!req.validateEnvironmentRequest(context.appConfig)) {
+    if (!req.validateEnvironmentRequest(appConfig)) {
       res.status(400).send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment, i18n);
     const {resourceId} = (0, import_identity.getResourceIdentity)(req);
     const resource = await resourceRegistry.getResource(resourceId, runtimeEnvironment, runtimeParams);
     if (req.isSiteGeneration()) {

package/build/cjs/middleware/utils/error-handling.cjs

@@ -27,6 +27,7 @@ __export(exports, {
   handleErrors: () => handleErrors
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_diagnostics2 = __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};
@@ -42,11 +43,11 @@ function handleErrors(middleware) {
       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);
+        import_diagnostics2.logger.error("LWR Diagnostic Error: " + err.message);
+        import_diagnostics2.logger.error(err.diagnostics);
+        import_diagnostics2.logger.error(err.stack);
       } else {
-        console.error(err);
+        import_diagnostics2.logger.error(err);
       }
       const {status, message} = createReturnStatus(err, req.originalUrl);
       res.status(status);

package/build/cjs/middleware/utils/metadata.cjs

@@ -32,7 +32,7 @@ async function normalizeResolvedUris(bundleDefinition, runtimeEnvironment, runti
   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 id = await (0, import_shared_utils.getVersionedModuleId)(childSpecifier, moduleRegistry, runtimeParams);
       const uri = await moduleBundler.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
       resolvedUris.push(uri);
     }
@@ -40,7 +40,7 @@ async function normalizeResolvedUris(bundleDefinition, runtimeEnvironment, runti
   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 id = await (0, import_shared_utils.getVersionedModuleId)(childSpecifier, moduleRegistry, runtimeParams);
       const uri = await moduleBundler.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
       resolvedUris.push(uri);
     }

package/build/cjs/middleware/utils/request.cjs

@@ -61,9 +61,9 @@ function getRequestProperties(pattern, req) {
   }
   return;
 }
-async function getRequestImporter(req, moduleRegistry) {
+async function getRequestImporter(req, moduleRegistry, runtimeParams) {
   const importerSpecifier = req.query.importer;
   const importerModuleId = (0, import_shared_utils.explodeSpecifier)(importerSpecifier);
-  const {entry} = await moduleRegistry.getModuleEntry(importerModuleId);
+  const {entry} = await moduleRegistry.getModuleEntry(importerModuleId, runtimeParams);
   return entry;
 }

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

@@ -31,16 +31,12 @@ 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);
+  const appConfig = context.appConfig;
+  const {environment: environmentConfig, i18n} = appConfig;
   return async (req, res) => {
-    if (!req.validateEnvironmentRequest(context.appConfig)) {
+    if (!req.validateEnvironmentRequest(appConfig)) {
       res.status(400);
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
       return;
@@ -50,8 +46,7 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
-    const {environment: environmentConfig} = context.appConfig;
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment, i18n);
     if (!runtimeParams.environment && environmentConfig?.default) {
       runtimeParams.environment = environmentConfig.default;
     }
@@ -71,8 +66,8 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
       if (!errorRoute) {
         throw err;
       }
-      import_shared_utils.logger.error(`[view-middleware] Route Error ${req.originalUrl}`);
-      import_shared_utils.logger.error(err);
+      import_diagnostics.logger.error(`[view-middleware] Route Error ${req.originalUrl}`);
+      import_diagnostics.logger.error(err);
       viewResponse = await resolve.call(viewHandler, viewRequest, errorRoute, runtimeEnvironment, runtimeParams);
       resolvedRoute = errorRoute;
     }
@@ -94,7 +89,7 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
 }
 function createConfigMiddleware(routes, context, viewHandler) {
   return async (req, res) => {
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment, context.appConfig.i18n);
     const {appId, encodedViewPath} = req.params;
     const route = routes.find((route2) => route2.id === appId);
     if (!route) {
@@ -138,7 +133,7 @@ function createNotFoundMiddleware(errorRoutes, context, viewHandler) {
 }
 function viewMiddleware(app, context) {
   const {appConfig, viewRegistry, moduleRegistry, routeHandlers} = context;
-  const {routes, errorRoutes} = appConfig;
+  const {i18n, routes, errorRoutes} = appConfig;
   const viewHandler = new import_view_registry.LwrViewHandler({viewRegistry, moduleRegistry, routeHandlers}, appConfig);
   for (const route of routes) {
     const paths = [route.path];
@@ -147,7 +142,14 @@ function viewMiddleware(app, context) {
       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)));
+    if (i18n.uriPattern === "path-prefix") {
+      const supportedStr = i18n.locales.map((l) => l.id).join("|");
+      paths.forEach((routePath) => {
+        const localizedPath = `/:locale(${supportedStr})${routePath}`;
+        import_diagnostics.logger.debug(`[view-middleware] Add localized path ${localizedPath}`);
+        paths.push(localizedPath);
+      });
+    }
     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)));

package/build/cjs/middleware.cjs

@@ -30,9 +30,11 @@ __export(exports, {
   localeMiddleware: () => import_locale_middleware.localeMiddleware,
   mappingMiddleware: () => import_mapping_middleware.mappingMiddleware,
   moduleMiddleware: () => import_module_middleware.moduleMiddleware,
+  requestProcessorMiddleware: () => import_request_processor_middleware.requestProcessorMiddleware,
   resourceMiddleware: () => import_resource_middleware.resourceMiddleware,
   viewMiddleware: () => import_view_middleware.viewMiddleware
 });
+var import_request_processor_middleware = __toModule(require("./middleware/request-processor-middleware.cjs"));
 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"));

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

@@ -30,16 +30,16 @@ var import_static_generation = __toModule(require("./static-generation.cjs"));
 var import_dir = __toModule(require("./utils/dir.cjs"));
 var import_network_dispatcher = __toModule(require("./utils/network-dispatcher.cjs"));
 var import_config = __toModule(require("@lwrjs/config"));
-var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 async function warmupServer(config, internalRequestKey) {
-  if (!import_shared_utils.logger.currentLevel || import_shared_utils.logger.currentLevel == import_shared_utils.WARN || import_shared_utils.logger.currentLevel == import_shared_utils.INFO) {
-    import_shared_utils.logger.setOptions({dedupe: new Set([import_shared_utils.WARN])});
+  if (!import_diagnostics.logger.currentLevel || import_diagnostics.logger.currentLevel == import_diagnostics.WARN || import_diagnostics.logger.currentLevel == import_diagnostics.INFO) {
+    import_diagnostics.logger.setOptions({dedupe: new Set([import_diagnostics.WARN])});
   }
-  import_shared_utils.logger.info("[Server Warmup] starting");
-  const {routes, staticSiteGenerator, port, basePath} = config;
+  import_diagnostics.logger.info("[Server Warmup] starting");
+  const {basePath, i18n, port, routes, staticSiteGenerator} = config;
   staticSiteGenerator.outputDir = import_dir.skipDirCreation;
   const urlRewriteMap = new Map();
   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");
+  await new import_static_generation.default().generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, new import_network_dispatcher.default(port, internalRequestKey), staticSiteGenerator.outputDir, i18n, urlRewriteMap);
+  import_diagnostics.logger.info("[Server Warmup] complete");
 }