@lwrjs/core 0.5.11-alpha.1 → 0.6.0-alpha.10

package/build/es/index.js

@@ -1,10 +1,11 @@
-import { deepFreeze, getExperimentalFeatures } from '@lwrjs/shared-utils';
+import { deepFreeze, getExperimentalFeatures, DEFAULT_LWR_BOOTSTRAP_CONFIG } from '@lwrjs/shared-utils';
 import { LwrCompiler } from '@lwrjs/compiler';
 import { LwrModuleBundler } from '@lwrjs/module-bundler';
 import { LwrModuleRegistry } from '@lwrjs/module-registry';
 import { LwrResourceRegistry } from '@lwrjs/resource-registry';
 import { LwrAssetRegistry } from '@lwrjs/asset-registry';
 import { LwrViewRegistry } from '@lwrjs/view-registry';
+import { LwrServerError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { normalizeConfig, explodeMode } from './env-config.js';
 import { LwrApplicationObserver } from './lwr-app-observer.js';
 import localeMiddleware from './middlewares/locale-middleware.js';
@@ -52,10 +53,12 @@ async function initContext(app, server, rawLwrConfig) {
     };
     const hookProviders = await getServices(rawLwrConfig.hooks, undefined, rawLwrConfig);
     const { lwrConfig, dataConfig, runtimeConfig } = await runConfigurationsHook(hookProviders, rawLwrConfig, rawDataConfig, rawRuntimeEnvConfig);
+    const assetTransformers = await getServices(rawLwrConfig.assetTransformers, undefined, rawLwrConfig);
     const appObserver = new LwrApplicationObserver();
     const appEmitter = appObserver.createLwrEmitter();
     const compiler = new LwrCompiler();
     const assetRegistry = new LwrAssetRegistry({
+        assetTransformers,
         appObserver,
         appEmitter,
         runtimeEnvironment: runtimeConfig,
@@ -96,9 +99,9 @@ async function initContext(app, server, rawLwrConfig) {
     const { cacheDir, lwc: { modules = [] }, routes, errorRoutes, rootDir, contentDir, layoutsDir, locker, amdLoader, esmLoader, environment, } = lwrConfig;
     const { onModuleDefinitionChange, onModuleSourceChange } = appObserver;
     const { notifyModuleDefinitionChanged, notifyModuleSourceChanged, notifyViewSourceChanged, notifyAssetSourceChanged, } = appEmitter;
-    const providerContext = deepFreeze({
+    const providerContext = {
         compiler,
-        appObserver: { onModuleDefinitionChange, onModuleSourceChange },
+        appObserver: deepFreeze({ onModuleDefinitionChange, onModuleSourceChange }),
         appEmitter: {
             notifyModuleDefinitionChanged: (payload) => notifyModuleDefinitionChanged.call(appEmitter, payload),
             notifyModuleSourceChanged: (payload) => notifyModuleSourceChanged.call(appEmitter, payload),
@@ -106,10 +109,11 @@ async function initContext(app, server, rawLwrConfig) {
             notifyAssetSourceChanged: (payload) => notifyAssetSourceChanged.call(appEmitter, payload),
         },
         moduleRegistry: moduleRegistry.getPublicApi(),
+        moduleBundler: moduleBundler,
         resourceRegistry: resourceRegistry.getPublicApi(),
         viewRegistry: viewRegistry.getPublicApi(),
         assetRegistry: assetRegistry.getPublicApi(),
-        config: {
+        config: deepFreeze({
             cacheDir,
             modules,
             routes,
@@ -121,9 +125,9 @@ async function initContext(app, server, rawLwrConfig) {
             amdLoader,
             esmLoader,
             environment,
-        },
-        runtimeEnvironment: runtimeConfig,
-    });
+        }),
+        runtimeEnvironment: deepFreeze(runtimeConfig),
+    };
     // Module Providers
     const moduleProviders = await getServices(lwrConfig.moduleProviders, providerContext, lwrConfig);
     moduleRegistry.addModuleProviders(moduleProviders);
@@ -132,7 +136,10 @@ async function initContext(app, server, rawLwrConfig) {
     resourceRegistry.addResourceProviders(resourceProviders);
     // View Providers
     const viewProviders = await getServices(lwrConfig.viewProviders, providerContext, lwrConfig);
+    // View Transformers
+    const viewTransformers = await getServices(rawLwrConfig.viewTransformers, providerContext, rawLwrConfig);
     viewRegistry.addViewProviders(viewProviders);
+    viewRegistry.addViewTransformers(viewTransformers);
     await viewRegistry.initializeViewProviders();
     // Asset Providers
     const assetProviders = await getServices(lwrConfig.assetProviders, providerContext, lwrConfig);
@@ -154,9 +161,15 @@ export class LwrApp {
     }
     async init() {
         if (!this.initialized) {
-            const context = await initContext(this.app, this.server, this.config);
-            initMiddlewares(this.app, this.server, context);
             this.initialized = true;
+            try {
+                const context = await initContext(this.app, this.server, this.config);
+                initMiddlewares(this.app, this.server, context);
+            }
+            catch (e) {
+                this.initialized = false;
+                throw e;
+            }
         }
     }
     async listen(callback) {
@@ -165,13 +178,20 @@ export class LwrApp {
         const { serverMode, port } = config;
         server.listen(port || config.port, async () => {
             if (process.env.WARMUP?.toLowerCase() === 'true') {
-                await warmupServer(config, app.getInternalRequestKey());
+                try {
+                    await warmupServer(config, app.getInternalRequestKey());
+                }
+                catch (err) {
+                    throw createSingleDiagnosticError({
+                        description: descriptions.SERVER.WARMUP_ERROR(err.message),
+                    }, LwrServerError);
+                }
             }
             callback?.({ serverMode, port });
         });
     }
     async close() {
-        await this.server.close();
+        this.server?.close && (await this.server.close());
     }
     getInternalServer() {
         return this.app.getImpl();
@@ -184,8 +204,25 @@ export async function generateStaticSite(config) {
     config = config || {};
     config.serverType = 'fs'; // override serverType
     const lwrApp = createServer(config);
+    overrideConfigAsSrc(lwrApp);
     await lwrApp.init();
     const dispatcher = lwrApp.getInternalServer();
     await new SiteGenerator().buildStaticApplication(lwrApp.getConfig(), dispatcher);
 }
+/**
+ * Create normalized config for static generation forcing the app config to come as src
+ */
+function overrideConfigAsSrc(lwrApp) {
+    if (getExperimentalFeatures().ENABLE_FINGERPRINTS) {
+        const normalizedConfig = lwrApp.getConfig();
+        const routes = normalizedConfig.routes || [];
+        for (const route of routes) {
+            route.bootstrap = {
+                ...DEFAULT_LWR_BOOTSTRAP_CONFIG,
+                ...route.bootstrap,
+                configAsSrc: true,
+            };
+        }
+    }
+}
 //# sourceMappingURL=index.js.map

package/build/es/middlewares/api-middleware.js

@@ -61,20 +61,20 @@ export default function apiMiddleware(app, context) {
                 // TODO might be able to remove this in the future but not sure how to properly send
                 // back bundleRecord imports with absolute uris (lwc is the main one)
                 if (bundleDef.bundleRecord.imports) {
-                    for (let index = 0; index < bundleDef.bundleRecord.imports.length; index++) {
-                        const theImport = bundleDef.bundleRecord.imports[index];
+                    for (const theImport of bundleDef.bundleRecord.imports) {
+                        const childSpecifier = theImport.specifier;
                         // eslint-disable-next-line no-await-in-loop
-                        const id = await getVersionedModuleId(theImport.specifier, moduleRegistry);
+                        const id = await getVersionedModuleId(childSpecifier, moduleRegistry);
                         // eslint-disable-next-line no-await-in-loop
                         const uri = await moduleRegistry.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
                         resolvedUris.push(uri);
                     }
                 }
                 if (bundleDef.bundleRecord.dynamicImports) {
-                    for (let index = 0; index < bundleDef.bundleRecord.dynamicImports.length; index++) {
-                        const theImport = bundleDef.bundleRecord.dynamicImports[index];
+                    for (const theImport of bundleDef.bundleRecord.dynamicImports) {
+                        const childSpecifier = theImport.specifier;
                         // eslint-disable-next-line no-await-in-loop
-                        const id = await getVersionedModuleId(theImport.specifier, moduleRegistry);
+                        const id = await getVersionedModuleId(childSpecifier, moduleRegistry);
                         // eslint-disable-next-line no-await-in-loop
                         const uri = await moduleRegistry.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
                         resolvedUris.push(uri);
@@ -307,7 +307,10 @@ export default function apiMiddleware(app, context) {
             ({ moduleIds } = getMappingIdentity(req));
             const { runtimeEnvironment, runtimeParams } = requestContext;
             const importMetadata = await getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
-            res.type('application/json').send(importMetadata);
+            // Include import metadata as an object for use with the static site generator
+            res.setMetadata({ importMetadata });
+            // Respond to request
+            res.status(200).type('application/json').send(importMetadata);
         }
         catch (e) {
             console.log(e);

package/build/es/middlewares/ui-middleware.js

@@ -2,13 +2,14 @@ import ms from 'ms';
 import { DiagnosticsError } from '@lwrjs/diagnostics';
 import { LwrViewHandler } from '@lwrjs/view-registry';
 import { isSupportedEnvironment } from './utils.js';
+import { getClientBootstrapConfigurationRoutes, extractRequestParams } from '@lwrjs/shared-utils';
 export default function uiMiddleware(app, context) {
     const { viewRegistry, moduleRegistry, runtimeEnvironment: defaultRuntimeEnvironment } = context;
     const { environment: environmentConfig, routes, errorRoutes } = context.appConfig;
     const route404 = errorRoutes.find((r) => r.status === 404);
     const route500 = errorRoutes.find((r) => r.status === 500);
     const viewHandler = new LwrViewHandler({ viewRegistry, moduleRegistry }, context.appConfig);
-    async function sendResponse(req, res, route, defaultStatus = 200) {
+    async function sendViewResponse(req, res, route, defaultStatus = 200) {
         if (!req.validateJsonRequest()) {
             res.status(400).send({ error: 'Accept header and json query parameter are incompatible' });
             return;
@@ -28,7 +29,7 @@ export default function uiMiddleware(app, context) {
                 url: req.originalUrl,
                 params: req.params,
                 query: req.query,
-                requestPath: req.path,
+                requestPath: req.path, // Runtime resolved version vs. the original route path
             };
             const response = req.isJsonRequest()
                 ? await viewHandler.getViewJson(viewRequest, route, runtimeEnvironment, runtimeParams)
@@ -58,27 +59,33 @@ export default function uiMiddleware(app, context) {
                 console.error(error);
             }
             if (route500 && defaultStatus !== 500) {
-                await sendResponse(req, res, route500, 500);
+                await sendViewResponse(req, res, route500, 500);
             }
             else {
                 res.status(500).send(`500 - Error retrieving view for route "${route.id}"`);
             }
         }
     }
-    async function sendConfigurationResponse(req, res, route, defaultStatus = 200) {
+    async function sendConfigurationResponse(req, res, defaultStatus = 200) {
         const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(defaultRuntimeEnvironment);
-        const { originalUrl, path } = req;
-        const { apiVersion, format, appId, locale } = req.params;
-        const rootCfgPath = `/${apiVersion}/application/${format}/l/${locale}/ai/${appId}/configuration/ci`;
-        const url = originalUrl.replace(rootCfgPath, '');
-        const requestPath = path.replace(rootCfgPath, '');
+        const { appId, encodedViewPath } = req.params;
+        // Match the route id
+        const route = routes.find((route) => route.id === appId);
+        if (!route) {
+            res.status(404).send({ error: `LWR configuration for "${appId} is not available"` });
+            return;
+        }
         try {
+            // decode the resolved view path and extract any params.
+            const url = decodeURIComponent(encodedViewPath);
+            const requestPath = route.path;
+            const params = extractRequestParams(requestPath, url, req.params);
             // HTML document
             const viewRequest = {
                 url,
-                params: req.params,
+                params,
                 query: req.query,
-                requestPath,
+                requestPath, // Runtime resolved version vs. the original route path
             };
             const response = await viewHandler.getViewConfiguration(viewRequest, route, runtimeEnvironment, runtimeParams);
             if (!response) {
@@ -108,7 +115,7 @@ export default function uiMiddleware(app, context) {
                 console.error(error);
             }
             if (route500 && defaultStatus !== 500) {
-                await sendResponse(req, res, route500, 500);
+                await sendViewResponse(req, res, route500, 500);
             }
             else {
                 res.status(500).send(`500 - Error retrieving route "${route.id}"`);
@@ -120,29 +127,29 @@ export default function uiMiddleware(app, context) {
         // Seems like we only support get or post
         if (route.method === 'post') {
             app.post(route.path, async (req, res) => {
-                await sendResponse(req, res, route);
+                await sendViewResponse(req, res, route);
             });
         }
         else {
             // vanity urls
             app.get(route.path, async (req, res) => {
-                await sendResponse(req, res, route);
+                await sendViewResponse(req, res, route);
             });
             // canonical URL
             app.get([
                 `/:apiVersion/application/:format/l/:locale/ai/:appId${route.path}`,
                 `/:apiVersion/application/:format/l/:locale/e/:environment/ai/:appId${route.path}`,
+                `/:apiVersion/application/:format/ai/:appId${route.path}`,
+                `/:apiVersion/application/:format/e/:environment/ai/:appId${route.path}`,
             ], async (req, res) => {
-                await sendResponse(req, res, route);
-            });
-            app.get([
-                `/:apiVersion/application/:format/l/:locale/ai/:appId/configuration/ci${route.path}`,
-                `/:apiVersion/application/:format/l/:locale/e/:environment/ai/:appId/configuration/ci${route.path}`,
-            ], async (req, res) => {
-                await sendConfigurationResponse(req, res, route);
+                await sendViewResponse(req, res, route);
             });
         }
     });
+    const clientBootstrapConfigurationRoutes = getClientBootstrapConfigurationRoutes();
+    app.get(clientBootstrapConfigurationRoutes, async (req, res) => {
+        await sendConfigurationResponse(req, res);
+    });
     // TODO nrkruk - This needs to be more generalized and visible at the top level of our middleware code.
     // This is the only time we call initRoutes() - which adds all the routing middleware that has been declared previously
     // to the app (get()/post()/all()). Any routing middleware declared after this point will not be initialized
@@ -152,7 +159,7 @@ export default function uiMiddleware(app, context) {
     // -- Default 404 route -------------------------------------------------------------
     app.use(async (req, res) => {
         if (route404) {
-            await sendResponse(req, res, route404, 404);
+            await sendViewResponse(req, res, route404, 404);
         }
         else {
             res.status(404).send('404 - This page does not exist');

package/build/es/middlewares/utils.d.ts

@@ -2,16 +2,13 @@
 import http from 'http';
 import { EnvironmentConfig } from '@lwrjs/types';
 import qs from 'qs';
-interface E extends Error {
-    code: string;
-}
 /**
  * Create a status object Express can return when there is an error
  *
  * @param name - string name of the problem module/resource
- * @param error? - an Error/Diagnostic object
+ * @param error - an Error/Diagnostic object; thrown from try/catch
  */
-export declare function createReturnStatus(name: string, error: E): {
+export declare function createReturnStatus(name: string, error: unknown): {
     status: number;
     message: string;
 };

package/build/es/middlewares/utils.js

@@ -1,4 +1,4 @@
-import { LwrUnresolvableError, descriptions } from '@lwrjs/diagnostics';
+import { LwrUnresolvableError, descriptions, isNodeError } from '@lwrjs/diagnostics';
 import { pathToRegexp } from 'path-to-regexp';
 import qs from 'qs';
 import createDOMPurify from 'dompurify';
@@ -9,11 +9,11 @@ const DOMPurify = createDOMPurify(window);
  * Create a status object Express can return when there is an error
  *
  * @param name - string name of the problem module/resource
- * @param error? - an Error/Diagnostic object
+ * @param error - an Error/Diagnostic object; thrown from try/catch
  */
 export function createReturnStatus(name, error) {
     let returnStatus = { status: 501, message: '' };
-    if (error.code === 'NO_LWC_MODULE_FOUND') {
+    if (isNodeError(error) && error.code === 'NO_LWC_MODULE_FOUND') {
         returnStatus = { status: 404, message: descriptions.UNRESOLVABLE.LWC_MODULE(name).message };
     }
     else if (error instanceof LwrUnresolvableError &&

package/build/es/tools/static-generation.d.ts

@@ -1,16 +1,73 @@
-import { AssetConfig, LwrDispatcher, StaticSiteGenerator, LwrRoute, NormalizedLwrGlobalConfig } from '@lwrjs/types';
-import { ResourceContextOpts, SiteConfig } from './types.js';
+import { ImportMetadata, LwrDispatcher, StaticSiteGenerator, LwrRoute, NormalizedLwrGlobalConfig } from '@lwrjs/types';
+import { ResourceContextOpts, SiteConfig, ViewImportMetadata } from './types.js';
 export default class SiteGenerator {
-    dispatchResourceRecursive(url: string, dispatcher: LwrDispatcher, resourceOpts: ResourceContextOpts, siteConfig: SiteConfig): Promise<void>;
     /**
      * Build a static site in the configured directory
      *  - Generate all routes / modules
      *  - copy assets / resources
      *
-     * @param lwrApp
+     * @param config - LWR config for the site
+     * @param dispatcher - Facilitate server requests
      */
     buildStaticApplication(config: NormalizedLwrGlobalConfig, dispatcher: LwrDispatcher): Promise<void>;
+    /**
+     * Crawl all view routes for a site
+     */
     generateRoutes(staticSiteGenerator: StaticSiteGenerator, routes: LwrRoute[], dispatcher: LwrDispatcher, outputDir: string, urlRewriteMap?: Map<string, string>): Promise<void>;
+    /**
+     * Creates a function to dispatch the root requests for a given view url
+     */
+    private createGenerateURLFunction;
+    /**
+     * Primary recursive dispatch function.  Executes a URL and crawls its dependents.
+     *
+     * @param url - URL to execute
+     * @param dispatcher - Facilitates GET requests
+     * @param resourceOpts - Data about the URL to execute
+     * @param siteConfig - Running config for the current view
+     */
+    dispatchResourceRecursive(url: string, dispatcher: LwrDispatcher, resourceOpts: ResourceContextOpts, siteConfig: SiteConfig): Promise<void>;
+    /**
+     * Handle processing a returned javascript module or bundle and follow all returned references
+     * @param url - URL of the request javascript resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network dispatcher
+     */
+    private handleJavascriptResource;
+    /**
+     * Handle processing a returned module URI mapping resource and follow all returned references
+     * @param url - URL of the request mapping resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network dispatcher
+     */
+    private handleMappingResource;
+    /**
+     * Handle processing a returned HTML resource and process any provided view metadata
+     *
+     * @param url - URL of the requested HTML resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network Dispatcher
+     */
+    private handleHtmlResource;
+    /**
+     * Handle processing a returned view definition by following all returned references
+     * @param viewDefinition - Metadata about everything directly referenced form the view
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network dispatcher
+     */
+    private handleViewDefinition;
+    private dispatchJSResourceRecursive;
+    /**
+     * Handle processing a returned asset or resource
+     * @param url - URL of the requested asset or resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     */
+    private handleAssetOrResource;
+    private getResourcePathFromUrl;
     /**
      *  Write out redirect mapping files for static hosting services like netlify. Examples for why this is needed:
      *  -- Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6 -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
@@ -19,7 +76,7 @@ export default class SiteGenerator {
      * @param outputDir
      * @param urlRewriteMap
      */
-    writeUrlMappings(outputDir: string, urlRewriteMap: Map<string, string>): void;
+    private writeNetlifyRedirectConfig;
     /**
      * Copy over assets
      * TODO this results in duplicate assets at the moment since assets can be referenced multiple ways:
@@ -29,6 +86,38 @@ export default class SiteGenerator {
      * @param assets AssetConfig
      *
      */
-    copyAssets(assets: AssetConfig[], outputDir: string): void;
+    private copyAssets;
+    /**
+     * Create a new site config for the current view
+     */
+    private createSiteConfig;
+    private filterExperimentalFeatures;
+    /**
+     * Add any additional import metadata collected during static site generation to the Client Bootstrap Config for this view.
+     */
+    private addAdditionalImportMetadataToViewConfig;
+}
+export declare class ViewImportMetadataImpl implements ViewImportMetadata {
+    private existing;
+    private additional;
+    constructor(existingImportMetadata: ImportMetadata, additionalImportMetadata?: ImportMetadata);
+    /**
+     * Get the additional import metadata collected while generating this view
+     * @returns
+     */
+    getAdditionalImportMetadata(): ImportMetadata;
+    /**
+     * Adds any new imports found to the additional metadata map.  Returns a filtered
+     * map of imports not in the initial view
+     */
+    addAdditionalMetadata(newMetadata: ImportMetadata): ImportMetadata;
+    /**
+     * Filter out any existing import metadata the would have already been sent back with the view from set of additional metadata detected
+     */
+    private filterMetadata;
+    /**
+     * Merge new import metadata into target import metadata
+     */
+    private mergeImportMetadata;
 }
 //# sourceMappingURL=static-generation.d.ts.map