@lwrjs/core 0.9.0-alpha.8 → 0.9.0

package/build/es/middleware/utils/identity.js

@@ -0,0 +1,62 @@
+import { explodeSpecifier, explodeSpecifiers, LATEST_SIGNATURE } from '@lwrjs/shared-utils';
+import { createSingleDiagnosticError, descriptions, LwrUnresolvableError } from '@lwrjs/diagnostics';
+function validateSpecifier(specifer) {
+    return specifer.indexOf('../') < 0;
+}
+export function getModuleIdentity(req, importer) {
+    const { specifier, signature } = req.params;
+    if (validateSpecifier(specifier) === false) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier),
+        }, LwrUnresolvableError);
+    }
+    const moduleId = explodeSpecifier(specifier);
+    return {
+        moduleId: {
+            ...moduleId,
+            importer,
+        },
+        signature,
+    };
+}
+export function getMappingIdentity(req) {
+    const { specifiers } = req.params;
+    const moduleIds = explodeSpecifiers(specifiers).map((obj) => ({
+        ...obj,
+        importer: req.query.importer,
+    }));
+    return {
+        moduleIds,
+    };
+}
+export function getResourceIdentity(req) {
+    const { specifier, signature = LATEST_SIGNATURE } = req.params;
+    if (validateSpecifier(specifier) === false) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier),
+        }, LwrUnresolvableError);
+    }
+    const resourceId = explodeSpecifier(specifier);
+    return {
+        resourceId,
+        signature,
+    };
+}
+export function getAssetIdentity(req) {
+    const { signature, immutable, assetType: type } = req.params;
+    const specifier = signature && type ? '/' + req.params[0] : req.originalUrl.split('?')[0];
+    if (validateSpecifier(specifier) === false) {
+        throw createSingleDiagnosticError({
+            description: descriptions.UNRESOLVABLE.INVALID_SPECIFIER(specifier),
+        }, LwrUnresolvableError);
+    }
+    return {
+        immutable,
+        assetId: {
+            specifier,
+            type,
+        },
+        signature: signature || LATEST_SIGNATURE,
+    };
+}
+//# sourceMappingURL=identity.js.map

package/build/es/middleware/utils/metadata.d.ts

@@ -0,0 +1,3 @@
+import type { BundleDefinition, ModuleBundler, ModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export declare function normalizeResolvedUris(bundleDefinition: BundleDefinition, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, moduleBundler: ModuleBundler, moduleRegistry: ModuleRegistry): Promise<string[]>;
+//# sourceMappingURL=metadata.d.ts.map

package/build/es/middleware/utils/metadata.js

@@ -0,0 +1,24 @@
+import { getVersionedModuleId } from '@lwrjs/shared-utils';
+export async function normalizeResolvedUris(bundleDefinition, runtimeEnvironment, runtimeParams, moduleBundler, moduleRegistry) {
+    const resolvedUris = [];
+    // 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 (bundleDefinition.bundleRecord.imports) {
+        for (const theImport of bundleDefinition.bundleRecord.imports) {
+            const childSpecifier = theImport.specifier;
+            const id = await getVersionedModuleId(childSpecifier, moduleRegistry);
+            const uri = await moduleBundler.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
+            resolvedUris.push(uri);
+        }
+    }
+    if (bundleDefinition.bundleRecord.dynamicImports) {
+        for (const theImport of bundleDefinition.bundleRecord.dynamicImports) {
+            const childSpecifier = theImport.specifier;
+            const id = await getVersionedModuleId(childSpecifier, moduleRegistry);
+            const uri = await moduleBundler.resolveModuleUri(id, runtimeEnvironment, runtimeParams);
+            resolvedUris.push(uri);
+        }
+    }
+    return resolvedUris;
+}
+//# sourceMappingURL=metadata.js.map

package/build/es/middleware/utils/request.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import type { MiddlewareRequest, ModuleRegistry } from '@lwrjs/types';
+import http from 'http';
+import qs from 'qs';
+interface Params {
+    [key: string]: string;
+}
+export declare function getRequestProperties(pattern: string, req: http.IncomingMessage): {
+    url: string;
+    params: Params;
+    query: qs.ParsedQs;
+} | undefined;
+export declare function getRequestImporter(req: MiddlewareRequest, moduleRegistry: ModuleRegistry): Promise<string>;
+export {};
+//# sourceMappingURL=request.d.ts.map

package/build/es/{middlewares/utils.js → middleware/utils/request.js}

@@ -1,5 +1,12 @@
-import { pathToRegexp } from 'path-to-regexp';
 import qs from 'qs';
+import { pathToRegexp } from 'path-to-regexp';
+import { explodeSpecifier } from '@lwrjs/shared-utils';
+function decodeParam(val) {
+    if (typeof val !== 'string' || val.length === 0) {
+        return val;
+    }
+    return decodeURIComponent(val);
+}
 // Adapted from https://github.com/expressjs/express/blob/master/lib/router/layer.js
 export function getRequestProperties(pattern, req) {
     const { url = '/' } = req;
@@ -13,7 +20,7 @@ export 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 !== undefined || !Object.hasOwnProperty.call(params, prop)) {
                 params[prop] = val;
             }
@@ -26,25 +33,10 @@ export function getRequestProperties(pattern, req) {
     }
     return;
 }
-/**
- * Check if the target environment is supported by the application
- *
- * @param environmentConfig - environment property from app config
- * @param targetEnvironment - environment value from module uri
- * @returns boolean
- */
-export 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);
+export async function getRequestImporter(req, moduleRegistry) {
+    const importerSpecifier = req.query.importer;
+    const importerModuleId = explodeSpecifier(importerSpecifier);
+    const { entry } = await moduleRegistry.getModuleEntry(importerModuleId);
+    return entry;
 }
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=request.js.map

package/build/es/middleware/view-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { InternalAppServer, ServerContext, ServerTypes } from '@lwrjs/types';
+export declare function viewMiddleware<T extends ServerTypes>(app: InternalAppServer<T>, context: ServerContext): void;
+//# sourceMappingURL=view-middleware.d.ts.map

package/build/es/middleware/view-middleware.js

@@ -0,0 +1,136 @@
+import { descriptions } from '@lwrjs/diagnostics';
+import { getClientRoutes } from '@lwrjs/router';
+import { decodeViewPath, extractRequestParams, getClientBootstrapConfigurationRoutes, shortestTtl, } from '@lwrjs/shared-utils';
+import { handleErrors } from './utils/error-handling.js';
+import { LwrViewHandler } from '@lwrjs/view-registry';
+const 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((route) => route.status === 500);
+    return async (req, res) => {
+        if (!req.validateEnvironmentRequest(context.appConfig)) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+            return;
+        }
+        if (!req.validateJsonRequest()) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_JSON().message);
+            return;
+        }
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        // set the default environment if an environment is configured in the app config
+        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);
+        }
+        // view response will be html by default
+        res.type('text/html');
+        // the default content type can be overridden if specified by the view response
+        if (viewResponse.headers) {
+            res.set(viewResponse.headers);
+        }
+        // pick the shortest TTL between the view response and route object
+        const cacheTtl = 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;
+        // match the app id to a route
+        const route = routes.find((route) => route.id === appId);
+        if (!route) {
+            res.status(404).send(descriptions.UNRESOLVABLE.APP_CONFIG(appId).message);
+            return;
+        }
+        // decode the resolved view path and extract any params.
+        const url = decodeViewPath(encodedViewPath);
+        const requestPath = route.path;
+        const params = 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(descriptions.UNRESOLVABLE.VIEW_CONFIG(url).message);
+            return;
+        }
+        // Pick the shortest TTL between the view response and route object
+        const cacheTtl = 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(descriptions.UNRESOLVABLE.VIEW(req.originalUrl).message);
+    };
+}
+export function viewMiddleware(app, context) {
+    const { appConfig, viewRegistry, moduleRegistry, routeHandlers } = context;
+    const { routes, errorRoutes } = appConfig;
+    const viewHandler = new LwrViewHandler({ viewRegistry, moduleRegistry, routeHandlers }, appConfig);
+    // create and attach middleware for each route
+    for (const route of routes) {
+        const paths = [route.path];
+        const subRoutes = route.subRoutes && 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, handleErrors(createViewMiddleware(route, errorRoutes, context, viewHandler)));
+    }
+    // create and attach middleware for bootstrap configurations
+    app.get(getClientBootstrapConfigurationRoutes(), handleErrors(createConfigMiddleware(routes, context, viewHandler)));
+    // create and attach a greedy middleware to handle unsupported paths
+    // NOTE: a greedy `all` is used over `use` due to the way middleware is mounted in the server abstraction
+    app.get('/' + app.getRegexWildcard(), handleErrors(createNotFoundMiddleware(errorRoutes, context, viewHandler)));
+}
+//# sourceMappingURL=view-middleware.js.map

package/build/es/middleware.d.ts

@@ -1,15 +1,9 @@
-import { InternalAppServer, ServerContext, ServerTypes } from '@lwrjs/types';
-/**
- * Mount all LWR middleware to the provided LWR application
- *
- * @privateRemarks
- * This is exposed as a submodule to mitigate installing unnecessary dependency and minimize Lambda
- * handler bundle size. For example, importing `@lwrjs/core` will pull in ALL `@lwrjs/server` dependencies
- * which includes both `koa` and `express`. Importing `@lwrjs/core/middleware` will only pull in the
- * middleware dependencies.
- *
- * @param {InternalAppServer} app - LWR application
- * @param {ServerContext} context - LWR server context
- */
-export declare function attachLwrMiddleware<T extends ServerTypes>(app: InternalAppServer<T>, context: ServerContext): void;
+export { localeMiddleware } from './middleware/locale-middleware.js';
+export { hmrMiddleware } from './middleware/hmr-middleware.js';
+export { moduleMiddleware } from './middleware/module-middleware.js';
+export { bundleMiddleware } from './middleware/bundle-middleware.js';
+export { mappingMiddleware } from './middleware/mapping-middleware.js';
+export { assetMiddleware } from './middleware/asset-middleware.js';
+export { viewMiddleware } from './middleware/view-middleware.js';
+export { resourceMiddleware } from './middleware/resource-middleware.js';
 //# sourceMappingURL=middleware.d.ts.map

package/build/es/middleware.js

@@ -1,21 +1,13 @@
-import localeMiddleware from './middlewares/locale-middleware.js';
-import uiMiddleware from './middlewares/ui-middleware.js';
-import apiMiddleware from './middlewares/api-middleware.js';
-/**
- * Mount all LWR middleware to the provided LWR application
- *
- * @privateRemarks
- * This is exposed as a submodule to mitigate installing unnecessary dependency and minimize Lambda
- * handler bundle size. For example, importing `@lwrjs/core` will pull in ALL `@lwrjs/server` dependencies
- * which includes both `koa` and `express`. Importing `@lwrjs/core/middleware` will only pull in the
- * middleware dependencies.
- *
- * @param {InternalAppServer} app - LWR application
- * @param {ServerContext} context - LWR server context
- */
-export function attachLwrMiddleware(app, context) {
-    localeMiddleware(app, context);
-    apiMiddleware(app, context);
-    uiMiddleware(app, context);
-}
+// The middleware are exposed as a submodule to mitigate installing unnecessary dependency and minimize Lambda
+// handler bundle size. For example, importing `@lwrjs/core` will pull in ALL `@lwrjs/server` dependencies
+// which includes both `koa` and `express`. Importing `@lwrjs/core/middleware` will only pull in the
+// middleware dependencies.
+export { localeMiddleware } from './middleware/locale-middleware.js';
+export { hmrMiddleware } from './middleware/hmr-middleware.js';
+export { moduleMiddleware } from './middleware/module-middleware.js';
+export { bundleMiddleware } from './middleware/bundle-middleware.js';
+export { mappingMiddleware } from './middleware/mapping-middleware.js';
+export { assetMiddleware } from './middleware/asset-middleware.js';
+export { viewMiddleware } from './middleware/view-middleware.js';
+export { resourceMiddleware } from './middleware/resource-middleware.js';
 //# sourceMappingURL=middleware.js.map

package/build/es/tools/server-warmup.js

@@ -1,7 +1,7 @@
 import SiteGenerator from './static-generation.js';
 import { skipDirCreation } from './utils/dir.js';
 import NetworkDispatcher from './utils/network-dispatcher.js';
-import { explodeMode } from '@lwrjs/config';
+import { getRuntimeEnvironment } from '@lwrjs/config';
 import { logger, WARN, INFO } from '@lwrjs/shared-utils';
 export async function warmupServer(config, internalRequestKey) {
     // De-duplicate warming messages if log level is warn or info
@@ -9,17 +9,10 @@ export async function warmupServer(config, internalRequestKey) {
         logger.setOptions({ dedupe: new Set([WARN]) });
     }
     logger.info('[Server Warmup] starting');
-    const { routes, staticSiteGenerator, port, apiVersion, basePath, lwrVersion, serverMode } = config;
+    const { routes, staticSiteGenerator, port, basePath } = config;
     staticSiteGenerator.outputDir = skipDirCreation;
     const urlRewriteMap = new Map();
-    const runtimeEnvironment = {
-        ...explodeMode(serverMode),
-        apiVersion,
-        basePath,
-        lwrVersion,
-        debug: false,
-        serverMode,
-    };
+    const runtimeEnvironment = getRuntimeEnvironment(config);
     // For each locale, generate all the modules
     await new SiteGenerator().generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, new NetworkDispatcher(port, internalRequestKey), staticSiteGenerator.outputDir, urlRewriteMap);
     logger.info('[Server Warmup] complete');

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

@@ -1,4 +1,4 @@
-import { ImportMetadata, LwrDispatcher, StaticSiteGenerator, LwrRoute, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
+import type { ImportMetadata, LwrDispatcher, StaticSiteGenerator, LwrRoute, NormalizedLwrGlobalConfig, RuntimeEnvironment } from '@lwrjs/types';
 import { ResourceContextOpts, SiteConfig, ViewImportMetadata } from './types.js';
 export default class SiteGenerator {
     /**
@@ -6,6 +6,7 @@ export default class SiteGenerator {
      *  - Generate all routes / modules
      *  - copy assets / resources
      *
+     * @deprecated - use new build api
      * @param config - LWR config for the site
      * @param dispatcher - Facilitate server requests
      */
@@ -35,6 +36,9 @@ export default class SiteGenerator {
      * @param dispatcher - Network dispatcher
      */
     private handleJavascriptResource;
+    private addBundleToSiteMetadata;
+    private addResourceToSiteMetadata;
+    private addAssetToSiteMetadata;
     /**
      * Handle processing a returned module URI mapping resource and follow all returned references
      * @param url - URL of the request mapping resource
@@ -87,6 +91,8 @@ export default class SiteGenerator {
      *
      */
     private copyAssets;
+    private addAssetsToMetadata;
+    private addAssetToMetadata;
     /**
      * Create a new site config for the current view
      */
@@ -96,6 +102,10 @@ export default class SiteGenerator {
      * Add any additional import metadata collected during static site generation to the Client Bootstrap Config for this view.
      */
     private addAdditionalImportMetadataToViewConfig;
+    /**
+     * Capture additional metadata collected during the processing of a route or additional module
+     */
+    private captureAdditionalRouteMetadata;
 }
 export declare class ViewImportMetadataImpl implements ViewImportMetadata {
     private existing;