@lwrjs/core 0.11.0-alpha.8 → 0.11.0

package/build/cjs/context/server.cjs

@@ -32,7 +32,7 @@ var import_module_registry = __toModule(require("@lwrjs/module-registry"));
 var import_resource_registry = __toModule(require("@lwrjs/resource-registry"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_view_registry = __toModule(require("@lwrjs/view-registry"));
-var import_fs_watch = __toModule(require("@lwrjs/shared-utils/fs-watch"));
+var import_fs_watch = __toModule(require("@lwrjs/fs-watch"));
 function createServerContext(appConfig, runtimeEnvironment, globalData) {
   const appObserver = new import_shared_utils.LwrApplicationObserver();
   const appEmitter = appObserver.createLwrEmitter();

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,6 +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) {
+  (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);
@@ -190,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

@@ -27,9 +27,10 @@ __export(exports, {
   assetMiddleware: () => assetMiddleware
 });
 var import_path = __toModule(require("path"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_identity = __toModule(require("./utils/identity.cjs"));
 var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
-var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 function createAssetMiddleware(context) {
   const {
     assetRegistry,
@@ -51,7 +52,14 @@ function createAssetMiddleware(context) {
         res.sendStatus(302);
         return;
       }
-      const asset = await assetRegistry.getAsset({...assetId, signature}, runtimeEnvironment, req.isSiteGeneration());
+      const asset = await (0, import_instrumentation.getTracer)().trace({
+        name: import_instrumentation.RequestHandlerSpan.GetAsset,
+        attributes: {
+          specifier: assetId.specifier
+        }
+      }, () => {
+        return assetRegistry.getAsset({...assetId, signature}, runtimeEnvironment, req.isSiteGeneration());
+      });
       if (req.isSiteGeneration()) {
         res.setSiteGenerationMetadata({asset});
       }

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

@@ -28,16 +28,22 @@ __export(exports, {
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_request = __toModule(require("./utils/request.cjs"));
 var import_identity = __toModule(require("./utils/identity.cjs"));
 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,
+    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,7 +53,7 @@ function createBundleMiddleware(context) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment);
     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) {
@@ -55,7 +61,14 @@ function createBundleMiddleware(context) {
       return;
     }
     const sourceMapUrl = req.path.replace("/bundle/", "/sourcemaps/bundle/");
-    const bundleDefinition = await moduleBundler.getModuleBundle(moduleId, {...runtimeEnvironment, bundle: true, sourceMapUrl}, runtimeParams);
+    const bundleDefinition = await (0, import_instrumentation.getTracer)().trace({
+      name: import_instrumentation.RequestHandlerSpan.GetBundle,
+      attributes: {
+        specifier: moduleId.specifier
+      }
+    }, () => {
+      return moduleBundler.getModuleBundle(moduleId, {...runtimeEnvironment, bundle: true, sourceMapUrl}, runtimeParams);
+    });
     if (req.isSiteGeneration()) {
       res.setSiteGenerationMetadata({
         moduleDefinition: bundleDefinition,
@@ -69,14 +82,14 @@ function createBundleMiddleware(context) {
   };
 }
 function createSourceMapMiddleware(context) {
-  const {moduleBundler} = context;
+  const {appConfig, 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);
     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

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

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

@@ -28,19 +28,29 @@ __export(exports, {
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 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,
+    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);
     const {moduleIds} = (0, import_identity.getMappingIdentity)(req);
-    const importMetadata = await (0, import_shared_utils.getImportMetadataMappings)(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
+    const importMetadata = await (0, import_instrumentation.getTracer)().trace({
+      name: import_instrumentation.RequestHandlerSpan.GetMapping
+    }, () => {
+      return (0, import_shared_utils.getImportMetadataMappings)(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
+    });
     if (req.isSiteGeneration()) {
       res.setSiteGenerationMetadata({importMetadata});
     }

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

@@ -28,15 +28,16 @@ __export(exports, {
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_request = __toModule(require("./utils/request.cjs"));
 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, 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,14 +47,21 @@ function createModuleMiddleware(context) {
       res.send(import_diagnostics.descriptions.UNRESOLVABLE.INVALID_JSON().message);
       return;
     }
-    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(defaultRuntimeEnvironment);
     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);
       return;
     }
-    const moduleDefinition = await moduleRegistry.getLinkedModule(moduleId, {...runtimeEnvironment, bundle: false}, runtimeParams);
+    const moduleDefinition = await (0, import_instrumentation.getTracer)().trace({
+      name: import_instrumentation.RequestHandlerSpan.GetModule,
+      attributes: {
+        specifier: moduleId.specifier
+      }
+    }, () => {
+      return moduleRegistry.getLinkedModule(moduleId, {...runtimeEnvironment, bundle: false}, runtimeParams);
+    });
     const {ownHash, linkedSource} = moduleDefinition;
     if (signature !== import_shared_utils.LATEST_SIGNATURE && ownHash !== signature) {
       res.status(404).send(import_diagnostics.descriptions.UNRESOLVABLE.SIGNED_MODULE(moduleId.specifier, signature).message);

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,13 @@ 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, 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);
     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/view-middleware.cjs

@@ -29,12 +29,15 @@ __export(exports, {
 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_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_error_handling = __toModule(require("./utils/error-handling.cjs"));
 var import_view_registry = __toModule(require("@lwrjs/view-registry"));
 function createViewMiddleware(route, errorRoutes, context, viewHandler) {
   const errorRoute = errorRoutes.find((route2) => route2.status === 500);
+  const appConfig = context.appConfig;
+  const {environment: environmentConfig} = 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;
@@ -45,7 +48,6 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
       return;
     }
     const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
-    const {environment: environmentConfig} = context.appConfig;
     if (!runtimeParams.environment && environmentConfig?.default) {
       runtimeParams.environment = environmentConfig.default;
     }
@@ -59,15 +61,29 @@ function createViewMiddleware(route, errorRoutes, context, viewHandler) {
     let viewResponse;
     let resolvedRoute;
     try {
-      viewResponse = await resolve.call(viewHandler, viewRequest, route, runtimeEnvironment, runtimeParams);
+      viewResponse = await (0, import_instrumentation.getTracer)().trace({
+        name: import_instrumentation.RequestHandlerSpan.GetView,
+        attributes: {
+          view: route.id
+        }
+      }, () => {
+        return resolve.call(viewHandler, viewRequest, route, runtimeEnvironment, runtimeParams);
+      });
       resolvedRoute = route;
     } catch (err) {
       if (!errorRoute) {
         throw err;
       }
-      import_shared_utils.logger.error(`[view-middleware] Route Error ${req.originalUrl}`);
-      import_shared_utils.logger.error(err);
-      viewResponse = await resolve.call(viewHandler, viewRequest, errorRoute, runtimeEnvironment, runtimeParams);
+      import_diagnostics.logger.error(`[view-middleware] Route Error ${req.originalUrl}`);
+      import_diagnostics.logger.error(err);
+      viewResponse = await (0, import_instrumentation.getTracer)().trace({
+        name: import_instrumentation.RequestHandlerSpan.GetView,
+        attributes: {
+          view: errorRoute.id
+        }
+      }, () => {
+        return resolve.call(viewHandler, viewRequest, errorRoute, runtimeEnvironment, runtimeParams);
+      });
       resolvedRoute = errorRoute;
     }
     if (req.isSiteGeneration()) {
@@ -142,15 +158,28 @@ function viewMiddleware(app, context) {
       subRoutes.routes.forEach((subRoute) => subRoute.uri !== route.path && paths.push(`${prefix}${subRoute.uri}`));
     }
     if (i18n.uriPattern === "path-prefix") {
-      const supportedStr = i18n.locales.map((l) => l.id).join("|");
+      const defaultLocalePaths = paths.map((routePath) => `/${i18n.defaultLocale}${routePath}`);
+      const supportedStr = i18n.locales.map((l) => l.id).filter((id) => id !== i18n.defaultLocale).join("|");
       paths.forEach((routePath) => {
         const localizedPath = `/:locale(${supportedStr})${routePath}`;
-        import_shared_utils.logger.debug(`[view-middleware] Add localized path ${localizedPath}`);
         paths.push(localizedPath);
       });
+      addDefaultLocaleRedirects(i18n.defaultLocale, defaultLocalePaths, app);
     }
+    import_diagnostics.logger.debug(`[view-middleware] Add view paths ${paths}`);
     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)));
 }
+function addDefaultLocaleRedirects(defaultLocale, defaultLocalePaths, app) {
+  import_diagnostics.logger.debug(`[view-middleware] Add default localized paths ${defaultLocalePaths}`);
+  app.get(defaultLocalePaths, (req, res) => {
+    let modifiedPath = req.originalUrl.replace(`/${defaultLocale}`, "");
+    if (modifiedPath.indexOf("/") !== 0) {
+      modifiedPath = `/${modifiedPath}`;
+    }
+    res.setHeader("Location", modifiedPath);
+    return res.sendStatus(301);
+  });
+}

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, 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");
+  import_diagnostics.logger.info("[Server Warmup] complete");
 }