@lwrjs/core 0.9.0-alpha.2 → 0.9.0-alpha.21

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

@@ -0,0 +1,61 @@
+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/mapping-middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  mappingMiddleware: () => mappingMiddleware
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+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;
+  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;
+    }
+    const {runtimeEnvironment, runtimeParams} = req.getRuntimeContext(context.runtimeEnvironment);
+    const {moduleIds} = (0, import_identity.getMappingIdentity)(req);
+    const importMetadata = await (0, import_shared_utils.getImportMetadataMappings)(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
+    if (req.isSiteGeneration()) {
+      res.setSiteGenerationMetadata({importMetadata});
+    }
+    res.status(200).type("application/json").send(importMetadata);
+  };
+}
+function mappingMiddleware(app, context) {
+  app.get([
+    `/:apiVersion/mapping/:format/:compat/l/:locale/e/:environment/bi/:bundleSpecifier/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/l/:locale/e/:environment/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/l/:locale/bi/:bundleSpecifier/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/e/:environment/bi/:bundleSpecifier/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/l/:locale/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/e/:environment/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/bi/:bundleSpecifier/mp/:specifiers`,
+    `/:apiVersion/mapping/:format/:compat/mp/:specifiers`
+  ], (0, import_error_handling.handleErrors)(createMappingMiddleware(context)));
+}

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

@@ -0,0 +1,88 @@
+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/module-middleware.ts
+__markAsModule(exports);
+__export(exports, {
+  moduleMiddleware: () => moduleMiddleware
+});
+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 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 unsignedRedirect = (0, import_unsigned_module_redirect.createUnsignedModuleRedirect)(moduleRegistry);
+  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 importer = req.query.importer ? await (0, import_request.getRequestImporter)(req, moduleRegistry) : 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 {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);
+      return;
+    }
+    if (req.isSiteGeneration()) {
+      res.setSiteGenerationMetadata({moduleDefinition});
+    }
+    if (req.isJsonRequest()) {
+      const json = await (0, import_shared_utils.serializeModuleToJson)(linkedSource, moduleDefinition, moduleRegistry, runtimeParams);
+      res.status(200).type("application/json").send(json);
+      return;
+    }
+    res.status(200).type("application/javascript").send(linkedSource);
+  };
+}
+function moduleMiddleware(app, context) {
+  app.get([
+    `/:apiVersion/module/:format/:compat/l/:locale/e/:environment/mi/:specifier/latest/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/l/:locale/e/:environment/mi/:specifier/s/:signature/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/l/:locale/mi/:specifier/latest/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/l/:locale/mi/:specifier/s/:signature/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/e/:environment/mi/:specifier/latest/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/e/:environment/mi/:specifier/s/:signature/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/mi/:specifier/latest/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/mi/:specifier/s/:signature/:prettyUrl?`,
+    `/:apiVersion/module/:format/:compat/l/:locale/e/:environment/mi/:specifier`,
+    `/:apiVersion/module/:format/:compat/l/:locale/mi/:specifier`,
+    `/:apiVersion/module/:format/:compat/e/:environment/mi/:specifier`,
+    `/:apiVersion/module/:format/:compat/mi/:specifier`
+  ], (0, import_error_handling.handleErrors)(createModuleMiddleware(context)));
+}

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/services.cjs → middleware/utils/error-handling.cjs}

@@ -21,23 +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/services.ts
+// packages/@lwrjs/core/src/middleware/utils/error-handling.ts
 __markAsModule(exports);
 __export(exports, {
-  getServiceModule: () => getServiceModule
+  handleErrors: () => handleErrors
 });
-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")});
-    }
-    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}`);
+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};
+  }
+  if (error instanceof import_diagnostics.LwrUnresolvableError) {
+    return {status: 404, message: error.message};
   }
+  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,93 @@
+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 (immutable) {
+  }
+  if (validateSpecifier(specifier) === false) {
+    throw (0, import_diagnostics.createSingleDiagnosticError)({
+      description: import_diagnostics.descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier)
+    }, import_diagnostics.LwrUnresolvableError);
+  }
+  return {
+    assetId: {
+      specifier,
+      type
+    },
+    signature: signature || import_shared_utils.LATEST_SIGNATURE
+  };
+}

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

@@ -21,38 +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/hooks.ts
+// packages/@lwrjs/core/src/middleware/utils/metadata.ts
 __markAsModule(exports);
 __export(exports, {
-  runConfigurationsHook: () => runConfigurationsHook
+  normalizeResolvedUris: () => normalizeResolvedUris
 });
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_config = __toModule(require("@lwrjs/config"));
-function normalizeRoutesBootstrap({routes, errorRoutes}) {
-  [...routes, ...errorRoutes].forEach((route) => {
-    if (!route.bootstrap) {
-      route.bootstrap = {...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG};
+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);
     }
-  });
-}
-async function runConfigurationsHook(hookPlugins, lwrConfig, dataConfig, runtimeConfig) {
-  for (const hookPlugin of hookPlugins) {
-    await hookPlugin.initConfigs(lwrConfig, dataConfig, runtimeConfig);
   }
-  try {
-    (0, import_config.validateLwrAppConfig)(JSON.stringify(lwrConfig), "post");
-  } catch (e) {
-    if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === "true") {
-      import_shared_utils.logger.warn("ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution");
-      console.dir(e, {depth: null});
-    } else {
-      throw e;
+  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);
     }
   }
-  normalizeRoutesBootstrap(lwrConfig);
-  return {
-    lwrConfig,
-    dataConfig,
-    runtimeConfig
-  };
+  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)));
+}