@lwrjs/lwc-ssr 0.17.2-alpha.2 → 0.17.2-alpha.20

package/build/cjs/__mocks__/renderer.cjs

@@ -21,7 +21,7 @@ var Renderer = class {
   }
   async render(components) {
     const results = {};
-    const errors = {};
+    const warnings = [];
     for (const [specifier] of Object.entries(components)) {
       const mockOutput = mockComponents[specifier];
       if (!mockOutput) {
@@ -29,14 +29,14 @@ var Renderer = class {
       }
       if (mockOutput.result) {
         results[specifier] = mockOutput.result;
+        if (mockOutput.result.warnings) {
+          warnings.push(...mockOutput.result.warnings);
+        }
       }
       if (mockOutput.error) {
-        errors[specifier] = mockOutput.error;
+        throw new Error(mockOutput.error);
       }
     }
-    if (Object.keys(errors).length) {
-      return {results, errors};
-    }
-    return {results, bundles: new Set([2, 3, 4])};
+    return {results, warnings, bundles: new Set([2, 3, 4])};
   }
 };

package/build/cjs/dataViewTransformer/index.cjs

@@ -28,6 +28,7 @@ __export(exports, {
 });
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_utils = __toModule(require("../utils.cjs"));
 var import_renderer = __toModule(require("../renderer.cjs"));
 var NAME = "preload-data-transformer";
@@ -44,7 +45,7 @@ function preloadDataViewTransformer(_options, {config, moduleBundler, resourceRe
       import_diagnostics.logger.debug({label: NAME, message: `Preload data for root component "${rootComponent}"`});
       const {
         results = {},
-        errors,
+        warnings,
         bundles
       } = await (0, import_instrumentation.getTracer)().trace({
         name: import_instrumentation.ViewSpan.PreloadData,
@@ -54,24 +55,28 @@ function preloadDataViewTransformer(_options, {config, moduleBundler, resourceRe
         if (!route) {
           throw new Error(`Unable to resolve configuration for view: ${viewContext.view.id}`);
         }
-        return await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render({[rootComponent]: {specifier: rootComponent, props: {}}}, route, viewContext.runtimeEnvironment, viewContext.runtimeParams);
-      });
-      if (errors) {
-        for (const err of Object.entries(errors)) {
-          import_diagnostics.logger.warn({
-            label: "preloadDataViewTransformer",
-            message: `Unexpected error during preload data: ${err[0]}`
-          }, err[1]);
+        try {
+          return await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render({[rootComponent]: {specifier: rootComponent, props: {}}}, route, viewContext.runtimeEnvironment, viewContext.runtimeParams);
+        } catch (e) {
+          if (e instanceof import_diagnostics.LwrStatusError)
+            throw e;
+          const message = import_diagnostics.descriptions.APPLICATION.PRELOAD_DATA_ERROR(rootComponent, (0, import_diagnostics.stringifyError)(e));
+          import_diagnostics.logger.warn({label: "preloadDataViewTransformer", message});
+          return {warnings: [message]};
         }
+      });
+      (0, import_utils.mergeWarnings)(metadata, warnings);
+      const result = results[rootComponent];
+      if (!result) {
         return {};
       }
-      const {props, markup, cache: {ttl} = {ttl: void 0}, status} = results[rootComponent];
+      const {props, markup, cache: {ttl} = {ttl: void 0}} = result || {};
       import_diagnostics.logger.verbose({label: NAME, message: "response", additionalInfo: props});
-      markup && (0, import_utils.addHeadMarkup)([results[rootComponent]], stringBuilder);
+      markup && (0, import_shared_utils.addHeadMarkup)([result.markup], stringBuilder);
       metadata.serverData = metadata.serverData || {};
       Object.assign(metadata.serverData, props);
       metadata.serverBundles = bundles ? new Set([...allBundles, ...bundles]) : allBundles;
-      return {cache: {ttl}, status};
+      return {cache: {ttl}};
     }
   };
 }

package/build/cjs/fetchController.cjs

@@ -30,7 +30,6 @@ var import_undici = __toModule(require("undici"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var ROUTE_CORE_HEADER = "X-SFDC-Route-Core";
 var CORE_CLIENTS = new Map();
 var FetchController = class {
   constructor(context) {
@@ -72,10 +71,9 @@ var FetchController = class {
       this.noOpActivated = false;
     };
     this.setFetchRequestContext = (context) => {
-      const {abortController, host, headers, requestDepth, coreProxy} = context;
+      const {abortController, host, headers, coreProxy} = context;
       this.host = host;
       this.headers = headers;
-      this.requestDepth = requestDepth;
       this.coreProxy = coreProxy;
       this.abortController = abortController;
     };
@@ -105,19 +103,12 @@ var FetchController = class {
     });
   }
   createFetchEndowment() {
-    return (request, init) => {
-      const {host = "", requestDepth = 1, coreProxy} = this;
-      const origin = coreProxy?.origin && coreProxy.origin.startsWith("http") ? coreProxy.origin : host;
+    return (request, init = {}) => {
+      const {host: forwardedOrigin = "", coreProxy} = this;
+      const origin = coreProxy?.origin && coreProxy.origin.startsWith("http") ? coreProxy.origin : forwardedOrigin;
       const {finalRequest, finalUrl} = this.getFinalRequest(request, origin);
-      const finalInit = {
-        ...init,
-        headers: {
-          ...init?.headers,
-          [import_shared_utils.REQUEST_DEPTH_HEADER]: String(requestDepth)
-        }
-      };
-      if (coreProxy || host && finalUrl.startsWith(host)) {
-        finalInit.headers[ROUTE_CORE_HEADER] = "true";
+      if (coreProxy || forwardedOrigin && finalUrl.startsWith(forwardedOrigin)) {
+        init.headers[import_shared_utils.ROUTE_CORE_HEADER] = "true";
       }
       const proxyStr = coreProxy ? JSON.stringify(coreProxy) : "none";
       const hasCookies = this.headers && this.headers.Cookie ? "yes" : "no";
@@ -127,32 +118,39 @@ var FetchController = class {
       });
       return (0, import_instrumentation.getTracer)().trace({
         name: import_instrumentation.ViewSpan.Fetch,
-        attributes: {url: finalUrl, fetchType: "cdn", coreProxy: proxyStr, hasCookies}
+        attributes: {
+          url: finalUrl,
+          fetchType: "cdn",
+          forwardedOrigin,
+          coreProxy: proxyStr,
+          hasCookies
+        }
       }, (span) => {
         const addInfoToSpan = (res) => {
           res.url && span.setAttributes({url: res.url});
           span.setAttributes({statusCode: res.status});
           return res;
         };
+        init.headers = {...init.headers, ...(0, import_shared_utils.getTraceHeaders)({}, span)};
         if (coreProxy) {
-          return this.fetchWithAgent(finalUrl, finalInit, host, coreProxy, span).then((res) => addInfoToSpan(res)).catch((err) => {
-            const {finalRequest: cdnRequest, finalUrl: cdnUrl} = this.getFinalRequest(request, host);
+          return this.fetchWithAgent(finalUrl, init, forwardedOrigin, coreProxy, span).then((res) => addInfoToSpan(res)).catch((err) => {
+            const {finalRequest: cdnRequest, finalUrl: cdnUrl} = this.getFinalRequest(request, forwardedOrigin);
             import_diagnostics.logger.warn(`Fetching data directly from Core failed, retrying through CDN: ${cdnUrl} Error is: ${err.message || err}`);
             span.setAttributes({fetchType: "cdnFallback"});
-            return fetch(cdnRequest, finalInit).then((res) => addInfoToSpan(res));
+            return fetch(cdnRequest, init).then((res) => addInfoToSpan(res));
           });
         }
-        return fetch(finalRequest, finalInit).then((res) => addInfoToSpan(res));
+        return fetch(finalRequest, init).then((res) => addInfoToSpan(res));
       });
     };
   }
-  getFinalRequest(request, host) {
+  getFinalRequest(request, origin) {
     let finalRequest;
     let finalUrl;
     if (request instanceof Request) {
       const curUrl = request.url;
       if (curUrl.startsWith("/")) {
-        finalUrl = host + curUrl;
+        finalUrl = origin + curUrl;
         finalRequest = new Request(finalUrl, request);
       } else {
         finalUrl = curUrl;
@@ -160,20 +158,22 @@ var FetchController = class {
       }
     } else {
       const curUrl = typeof request === "string" ? request : request.toString();
-      finalRequest = finalUrl = curUrl.startsWith("/") ? host + curUrl : curUrl;
+      finalRequest = finalUrl = curUrl.startsWith("/") ? origin + curUrl : curUrl;
     }
     return {finalRequest, finalUrl};
   }
-  async fetchWithAgent(rawUrl, init, forwardedHost, coreProxy, span) {
+  async fetchWithAgent(rawUrl, init, forwardedOrigin, coreProxy, span) {
     let {origin, servername} = coreProxy;
-    const host = coreProxy.host ?? forwardedHost.replace(/^https?:\/\//, "");
+    const forwardedHostname = (0, import_shared_utils.toHostname)(forwardedOrigin);
+    const hostHeader = coreProxy.host ?? forwardedHostname;
     const ENHANCED_DOMAIN_TLD = ".site.com";
     const MY_DOMAIN_TLD = ".salesforce.com";
-    if (forwardedHost.endsWith(ENHANCED_DOMAIN_TLD)) {
-      origin = forwardedHost.slice(0, -ENHANCED_DOMAIN_TLD.length) + MY_DOMAIN_TLD;
-      servername = origin;
+    if (forwardedHostname.endsWith(ENHANCED_DOMAIN_TLD)) {
+      const myHostname = forwardedHostname.slice(0, -ENHANCED_DOMAIN_TLD.length) + MY_DOMAIN_TLD;
+      origin = "https://" + myHostname;
+      servername = myHostname;
     } else if (origin.startsWith(".")) {
-      origin = forwardedHost + origin;
+      origin = "https://" + forwardedHostname + origin;
     }
     const urlParts = new URL(rawUrl);
     const path = urlParts.pathname + urlParts.search;
@@ -182,7 +182,7 @@ var FetchController = class {
       fetchType: "direct",
       url,
       coreUrl: url,
-      coreHostHeader: host,
+      coreHostHeader: hostHeader,
       coreServername: servername
     });
     let client = CORE_CLIENTS.get(origin);
@@ -197,7 +197,7 @@ var FetchController = class {
       ...init,
       method: init.method || "GET",
       path,
-      headers: {...init?.headers, Host: host},
+      headers: {...init?.headers, Host: hostHeader},
       servername
     }).then(async (res) => {
       span.setAttributes({coreStatusCode: res.statusCode});

package/build/cjs/moduleLoader.cjs

@@ -41,7 +41,7 @@ function createModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnv
 }
 async function createAMDModuleLoader(config, resourceRegistry, bundleRegistry, runtimeEnvironment, runtimeParams, serverData, bootstrapConfig, abortController) {
   const loaderConfig = (0, import_utils.getLoaderConfig)(BOOTSTRAP_SPECIFIER, config, runtimeParams, serverData);
-  const {context, controller} = createContext(loaderConfig, runtimeParams, runtimeEnvironment, abortController);
+  const {context, controller} = createContext(loaderConfig, runtimeParams, abortController);
   const contextKeyMap = new Map(Object.keys(context).map((key) => [key, true]));
   let run;
   context.LWR.customInit = async (lwr) => {
@@ -218,10 +218,9 @@ function isValidResolveResponse(res) {
 async function createESMModuleLoader() {
   throw new Error("ESM support coming soon.");
 }
-function createContext(LWR, runtimeParams, runtimeEnvironment, abortController) {
+function createContext(LWR, runtimeParams, abortController) {
   const fetchController = new import_fetchController.FetchController({
     host: runtimeParams.host,
-    requestDepth: runtimeParams.requestDepth,
     coreProxy: runtimeParams.coreProxy,
     abortController
   });

package/build/cjs/renderer.cjs

@@ -87,47 +87,25 @@ var Renderer = class {
   }
   async renderComponents(components, route, runtimeEnvironment, runtimeParams, serverData = {}, isFirstOf2PassSSR = false, abortController) {
     const results = {};
-    const errors = {};
+    const warnings = [];
     const roots = Object.keys(components);
     const services = (0, import_utils.getServerBootstrapServices)(route);
     const reevaluateModules = (0, import_shared_utils.getFeatureFlags)().REEVALUATE_MODULES === true;
     let loader, bootstrapServiceEvaluationMap;
     try {
       let lwcEngine, serverBootstrapServices;
-      ({bootstrapServiceEvaluationMap, loader, lwcEngine, serverBootstrapServices} = await this.createLoader(components, route, serverData, isFirstOf2PassSSR, services, errors, runtimeEnvironment, runtimeParams, abortController));
+      ({bootstrapServiceEvaluationMap, loader, lwcEngine, serverBootstrapServices} = await this.createLoader(components, route, serverData, isFirstOf2PassSSR, services, runtimeEnvironment, runtimeParams, abortController));
       const componentModules = await this.loadAppCode(components, route, roots, loader);
-      await this.executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, errors, runtimeEnvironment, runtimeParams);
+      await this.executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, warnings, runtimeEnvironment, runtimeParams);
       if (!route.bootstrap.ssr) {
-        if (Object.keys(errors).length) {
-          return {results, errors};
-        }
-        return {results, bundles: loader?.getBundles()};
+        return {results, warnings, bundles: loader?.getBundles()};
       }
       loader?.getFetchController().enableNoOpFetch();
       for (const component of componentModules) {
-        if (errors[component.specifier]) {
-          continue;
-        }
-        const {html, error} = await renderToString(lwcEngine.module, component, results[component.specifier].props);
-        if (error) {
-          errors[component.specifier] = error;
-          continue;
-        }
+        const {html} = await renderToString(lwcEngine.module, component, results[component.specifier].props);
         results[component.specifier].html = html;
       }
-      const bundles = loader?.getBundles();
-      if (Object.keys(errors).length) {
-        return {results, errors, bundles};
-      }
-      return {results, bundles};
-    } catch (e) {
-      const error = Object(e);
-      return {
-        errors: {
-          [roots.join(",")]: error.message ?? (0, import_diagnostics.stringifyError)(e)
-        },
-        bundles: loader?.getBundles()
-      };
+      return {results, warnings, bundles: loader?.getBundles()};
     } finally {
       loader?.getFetchController().disableNoOpFetch();
       loader?.getFetchController().enableFetchKillSwitch();
@@ -162,7 +140,7 @@ var Renderer = class {
       });
     });
   }
-  async executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, errors, runtimeEnvironment, runtimeParams) {
+  async executeDataServices(components, route, serverBootstrapServices, componentModules, serverData, results, warnings, runtimeEnvironment, runtimeParams) {
     return (0, import_instrumentation.getTracer)().trace({
       name: import_instrumentation.ViewSpan.ExecuteServices,
       attributes: {
@@ -189,21 +167,18 @@ var Renderer = class {
           basePath: runtimeParams.basePath || runtimeEnvironment.basePath,
           crossRequestCache: this.globalCache
         };
-        const {data, error} = await getServerData(component, context, serverData);
-        if (error) {
-          errors[component.specifier] = error;
-          continue;
-        }
+        const data = await getServerData(component, context, serverData);
         if (data) {
           results[component.specifier] = data;
         }
+        data.warnings && warnings.push(...data.warnings);
       }
       if (serverBootstrapServices) {
         serverBootstrapServices.evaluateServerDataHooks(serverData);
       }
     });
   }
-  async createLoader(components, route, serverData, isFirstOf2PassSSR, services, errors, runtimeEnvironment, runtimeParams, abortController) {
+  async createLoader(components, route, serverData, isFirstOf2PassSSR, services, runtimeEnvironment, runtimeParams, abortController) {
     return (0, import_instrumentation.getTracer)().trace({
       name: import_instrumentation.ViewSpan.CreateLoader,
       attributes: {
@@ -232,10 +207,7 @@ var Renderer = class {
             const serviceModules = await Promise.all(services.map((specifier) => loader?.load(specifier)));
             serverBootstrapServices = (0, import_serverBootstrapServices.createServerBootstrapServices)(loader);
             for (const service of serviceModules) {
-              const error = await (0, import_serverBootstrapServices.evaluateServerBootstrapModule)(service, serverBootstrapServices.serviceAPI);
-              if (error) {
-                errors[service.specifier] = error;
-              }
+              await (0, import_serverBootstrapServices.evaluateServerBootstrapModule)(service, serverBootstrapServices.serviceAPI);
             }
           }
           const ret = {
@@ -257,13 +229,13 @@ var Renderer = class {
   }
   resetFetchController(fetchController, runtimeParams, route, abortController) {
     fetchController.disableFetchKillSwitch();
+    const baseHeaders = {
+      [import_shared_utils.REQUEST_DEPTH_HEADER]: runtimeParams.requestDepth ?? "0",
+      ...(0, import_shared_utils.getTraceHeaders)(runtimeParams)
+    };
     fetchController.setFetchRequestContext({
       host: runtimeParams.host,
-      requestDepth: runtimeParams.requestDepth,
-      headers: route.bootstrap.includeCookiesForSSR ? {
-        Cookie: runtimeParams.cookie,
-        "True-Client-IP": runtimeParams.trueClientIP
-      } : {"True-Client-IP": runtimeParams.trueClientIP},
+      headers: route.bootstrap.includeCookiesForSSR ? {Cookie: runtimeParams.cookie, ...baseHeaders} : baseHeaders,
       coreProxy: runtimeParams.coreProxy,
       abortController
     });
@@ -299,30 +271,41 @@ function getServerData(component, context, serverData) {
     try {
       const data = await component.module.getServerData(context);
       Object.assign(serverData, data.props);
-      return {data};
+      const dataRes = data;
+      if (dataRes.status) {
+        const {code, location} = dataRes.status;
+        throw new import_diagnostics.LwrStatusError(void 0, code, location ? {location} : void 0);
+      }
+      return data;
     } catch (e) {
-      const message = `Error in "getServerData" for "${component.specifier}": ${(0, import_diagnostics.stringifyError)(e)}`;
-      import_diagnostics.logger.error(message);
-      return {error: message};
+      if (e instanceof import_diagnostics.LwrError)
+        throw e;
+      const statusError = e;
+      if (typeof statusError.status === "number") {
+        throw new import_diagnostics.LwrStatusError(statusError.message, statusError.status, statusError.headers);
+      }
+      throw new import_diagnostics.LwrApplicationError(`Error in "getServerData" for "${component.specifier}": ${(0, import_diagnostics.stringifyError)(e)}`);
     }
   });
 }
 async function renderToString(engine, component, props) {
+  const isSSRv2 = (0, import_shared_utils.getFeatureFlags)().SSR_COMPILER_ENABLED || false;
   return (0, import_instrumentation.getTracer)().trace({
     name: import_instrumentation.ViewSpan.RenderComponent,
-    attributes: {specifier: component.specifier}
+    attributes: {specifier: component.specifier, isSSRv2}
   }, async () => {
     try {
       const elementName = (0, import_shared_utils.moduleSpecifierToKebabCase)(component.specifier);
       const moduleDefault = component.module.default;
-      const html = (0, import_shared_utils.getFeatureFlags)().SSR_COMPILER_ENABLED ? await engine.renderComponent(elementName, moduleDefault, props, "sync") : engine.renderComponent(elementName, moduleDefault, props);
+      const html = isSSRv2 ? await engine.renderComponent(elementName, moduleDefault, props, "sync") : engine.renderComponent(elementName, moduleDefault, props);
       return {html};
     } catch (e) {
+      if (e instanceof import_diagnostics.LwrError)
+        throw e;
       const error = Object(e);
       const message = error.message ?? (0, import_diagnostics.stringifyError)(e);
       const detailedMessage = error.wcStack ? "An error occurred during server-side rendering for component stack: " + error.wcStack + ". Error was: " + message : `An error occurred during server-side rendering "${component.specifier}": ` + message;
-      import_diagnostics.logger.error(detailedMessage);
-      return {error: detailedMessage};
+      throw new import_diagnostics.LwrApplicationError(detailedMessage);
     }
   });
 }

package/build/cjs/serverBootstrapServices.cjs

@@ -76,9 +76,9 @@ function evaluateServerBootstrapModule(serviceModule, serviceApi) {
     try {
       await serviceModule.module.default(serviceApi);
     } catch (e) {
-      const message = `An SSR error occurred in bootstrap service "${serviceModule.specifier}": ${(0, import_diagnostics.stringifyError)(e)}`;
-      import_diagnostics.logger.error(message);
-      return message;
+      if (e instanceof import_diagnostics.LwrError)
+        throw e;
+      throw new import_diagnostics.LwrApplicationError(`An SSR error occurred in bootstrap service "${serviceModule.specifier}": ${(0, import_diagnostics.stringifyError)(e)}`);
     }
   });
 }

package/build/cjs/utils.cjs

@@ -25,18 +25,14 @@ var __toModule = (module2) => {
 __markAsModule(exports);
 __export(exports, {
   SSR_PROPS_ATTR: () => SSR_PROPS_ATTR,
-  addHeadMarkup: () => addHeadMarkup,
-  createHeadMarkup: () => createHeadMarkup,
-  createSsrErrorMarkup: () => createSsrErrorMarkup,
-  createSsrErrorMessage: () => createSsrErrorMessage,
   getLoaderConfig: () => getLoaderConfig,
   getLoaderId: () => getLoaderId,
   getLoaderShim: () => getLoaderShim,
   getPropsId: () => getPropsId,
   getRenderTimeout: () => getRenderTimeout,
-  getServerBootstrapServices: () => getServerBootstrapServices
+  getServerBootstrapServices: () => getServerBootstrapServices,
+  mergeWarnings: () => mergeWarnings
 });
-var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var DEFAULT_SSR_TIMEOUT = 5e3;
 var SSR_PROPS_ATTR = "data-lwr-props-id";
@@ -47,18 +43,6 @@ function getRenderTimeout() {
   const override = process.env.SSR_TIMEOUT;
   return override ? Number.parseInt(override) : DEFAULT_SSR_TIMEOUT;
 }
-function createSsrErrorMessage(specifier, e, fallback = true) {
-  const fallbackMsg = fallback ? " Falling back to client-side rendering." : "";
-  return `Server-side rendering for "${specifier}" failed.${fallbackMsg} Reason: ${(0, import_diagnostics.stringifyError)(e)}`;
-}
-function createSsrErrorMarkup(errors, basePath) {
-  let markup = '<div style="font-family:sans-serif;margin:50px;font-size:1.2em;"><h1>500: Server-side rendering failed</h1><p>Reasons:</p><ul>';
-  Object.entries(errors).forEach(([specifier, reason]) => {
-    markup += `<li><strong>${specifier}</strong>: ${(0, import_diagnostics.stringifyError)(reason)}</li>`;
-  });
-  markup += `</ul><p style="padding-top:1em;">See more information in the browser console. Contact your administrator for assistance.</p></div>`;
-  return markup;
-}
 async function getLoaderShim(resourceRegistry, runtimeEnvironment, bootstrapConfig) {
   const {debug} = runtimeEnvironment;
   const useDebug = debug && !(0, import_shared_utils.isLambdaEnv)();
@@ -124,52 +108,12 @@ function getServerBootstrapServices(route) {
     return acc;
   }, []);
 }
-function createMetaTags(meta) {
-  return meta.reduce((metaStr, {name, content, httpEquiv}) => {
-    if (!name && !content && !httpEquiv)
-      return metaStr;
-    const nameStr = name ? ` name="${name}"` : "", httpEquivStr = httpEquiv ? ` http-equiv="${httpEquiv}"` : "", contentStr = content ? ` content="${content}"` : "";
-    return metaStr + `<meta${nameStr}${httpEquivStr}${contentStr}>
-`;
-  }, "");
-}
-function createScriptTags(scripts) {
-  return scripts.reduce((scriptStr, {body}) => scriptStr + `<script type="application/ld+json">${body}</script>
-`, "");
-}
-function createLinkTags(links) {
-  return links.reduce((linkStr, {href, rel, as, fetchpriority}) => {
-    const relStr = rel ? ` rel="${rel}"` : "", asStr = as ? ` as="${as}"` : "", fetchStr = fetchpriority ? ` fetchpriority="${fetchpriority}"` : "";
-    return linkStr + `<link href="${href}"${relStr}${asStr}${fetchStr}>
-`;
-  }, "");
-}
-function createStyleTags(styles) {
-  return styles.reduce((styleStr, {body, id}) => {
-    const idStr = id ? ` id="${id}"` : "";
-    return styleStr + `<style type="text/css"${idStr}>${body}</style>
-`;
-  }, "");
-}
-function createHeadMarkup(results) {
-  let hasTitle = false;
-  return results.reduce((str, {markup: {title, scripts = [], meta = [], links = [], styles = []} = {}}) => {
-    if (title && !hasTitle) {
-      hasTitle = true;
-      str += `<title>${title}</title>
-`;
-    }
-    return str + createMetaTags(meta) + createScriptTags(scripts) + createLinkTags(links) + createStyleTags(styles);
-  }, "");
-}
-function addHeadMarkup(results, stringBuilder) {
-  const headMarkup = createHeadMarkup(Object.values(results));
-  if (headMarkup) {
-    const headIndex = stringBuilder.original.indexOf("</head>");
-    if (headIndex >= 0) {
-      stringBuilder.prependLeft(headIndex, headMarkup);
-    } else {
-      import_diagnostics.logger.error("Adding markup during server-side rendering failed. Could not find the </head> tag.");
-    }
+function mergeWarnings(metadata, warnings = []) {
+  if (!warnings.length)
+    return;
+  if (!metadata.serverDebug) {
+    metadata.serverDebug = {};
   }
+  metadata.serverDebug.warnings = metadata.serverDebug.warnings || [];
+  metadata.serverDebug.warnings.push(...warnings);
 }

package/build/cjs/viewProvider/index.cjs

@@ -30,7 +30,6 @@ var import_base_view_provider = __toModule(require("@lwrjs/base-view-provider"))
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_utils = __toModule(require("../utils.cjs"));
 var import_renderer = __toModule(require("../renderer.cjs"));
 var LwcViewProvider = class extends import_base_view_provider.default {
   constructor(_pluginConfig, providerConfig) {
@@ -59,56 +58,41 @@ var LwcViewProvider = class extends import_base_view_provider.default {
       filePath: specifier,
       viewId,
       properties: viewProperties,
-      render: async (runtimeParams, runtimeEnvironment) => {
+      render: async (context, runtimeEnvironment) => {
         const {config, moduleBundler, resourceRegistry} = this;
-        const {debug} = runtimeEnvironment;
         const element = (0, import_shared_utils.moduleSpecifierToKebabCase)(specifier);
         return (0, import_instrumentation.getTracer)().trace({
           name: import_instrumentation.ViewSpan.RenderPage,
           attributes: {specifier}
         }, async () => {
-          const route = this.routes.find((r) => r.id === viewId.id);
-          if (!route) {
-            throw new Error(`Unable to resolve configuration for view: ${viewId.id}`);
-          }
-          const {
-            results = {},
-            errors,
-            bundles
-          } = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render({[specifier]: {specifier, props: {}}}, route, runtimeEnvironment, Object(runtimeParams), void 0, true);
-          if (errors) {
-            const errorString = Object.values(errors).join(", ");
-            if (!debug || (0, import_shared_utils.isLocalDev)() && process.env.SSR_THROW_ERRORS === "true") {
-              throw new import_diagnostics.LwrApplicationError(import_diagnostics.descriptions.APPLICATION.SSR_ERROR(specifier, errorString));
+          try {
+            const route = this.routes.find((r) => r.id === viewId.id);
+            if (!route) {
+              throw new Error(`Unable to resolve configuration for view: ${viewId.id}`);
+            }
+            const {results = {}, bundles} = await (0, import_renderer.getRenderer)(config, moduleBundler, resourceRegistry).render({[specifier]: {specifier, props: {}}}, route, runtimeEnvironment, context.runtimeParams, void 0, true);
+            const {html, props, markup, cache, warnings} = results[specifier] || {};
+            if (!html) {
+              throw new Error("Failed to render content template component");
             }
-            const message = (0, import_utils.createSsrErrorMessage)(specifier, errorString, false);
-            import_diagnostics.logger.warn(message, errors[specifier]);
+            if (markup)
+              viewProperties.serverHeadMarkup = (0, import_shared_utils.createHeadMarkup)([markup]);
             return {
-              renderedView: (0, import_utils.createSsrErrorMarkup)(errors, this.runtimeEnvironment.basePath),
+              renderedView: html.replace(`<${element}`, `<${element} lwc:external`),
               metadata: {
-                serverDebug: {message: debug ? message : void 0},
+                serverData: props,
                 customElements: [],
-                assetReferences: []
-              }
+                assetReferences: [],
+                serverBundles: bundles,
+                serverDebug: {warnings}
+              },
+              cache
             };
+          } catch (e) {
+            if (e instanceof import_diagnostics.LwrError)
+              throw e;
+            throw new import_diagnostics.LwrApplicationError(import_diagnostics.descriptions.APPLICATION.SSR_ERROR(specifier, (0, import_diagnostics.stringifyError)(e)));
           }
-          const {html, props, markup, cache, status} = results[specifier];
-          if (!html) {
-            throw new Error(`Failed to render content template component '${specifier}'`);
-          }
-          if (markup)
-            viewProperties.serverHeadMarkup = (0, import_utils.createHeadMarkup)([results[specifier]]);
-          return {
-            renderedView: html.replace(`<${element}`, `<${element} lwc:external`),
-            metadata: {
-              serverData: props,
-              customElements: [],
-              assetReferences: [],
-              serverBundles: bundles
-            },
-            cache,
-            status
-          };
         });
       }
     };