@lwrjs/core 0.9.0-alpha.8 → 0.9.0

package/build/es/index.js

@@ -1,80 +1,117 @@
 import { getFeatureFlags, DEFAULT_LWR_BOOTSTRAP_CONFIG, logger } from '@lwrjs/shared-utils';
 import { createInternalServer } from '@lwrjs/server';
 import { LwrServerError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
-import { normalizeConfig } from '@lwrjs/config';
-import localeMiddleware from './middlewares/locale-middleware.js';
-import apiMiddleware from './middlewares/api-middleware.js';
-import uiMiddleware from './middlewares/ui-middleware.js';
-import hmrMiddleware from './middlewares/hmr-middleware.js';
-import baseMiddleware from './middlewares/base-middleware.js';
-import { getServices } from './context/services.js';
-import { resolveConfigurations } from './context/configurations.js';
-import { createProviderContext } from './context/provider.js';
-import { createServerContext } from './context/server.js';
+import { loadConfig, executeConfigHooks, executeStartHooks } from '@lwrjs/config';
+import { loadHooks, loadServices, loadRouteHandlers } from '@lwrjs/config/modules';
 import SiteGenerator from './tools/static-generation.js';
 import { warmupServer } from './tools/server-warmup.js';
-function initMiddlewares(app, server, serverContext) {
-    // Base middlewares for cookies, session, admin authentication, gzip, ...
-    baseMiddleware(app, serverContext);
+import { createServerContext } from './context/server.js';
+import { createProviderContext } from './context/provider.js';
+import { localeMiddleware } from './middleware/locale-middleware.js';
+import { moduleMiddleware } from './middleware/module-middleware.js';
+import { bundleMiddleware } from './middleware/bundle-middleware.js';
+import { mappingMiddleware } from './middleware/mapping-middleware.js';
+import { assetMiddleware } from './middleware/asset-middleware.js';
+import { viewMiddleware } from './middleware/view-middleware.js';
+import { resourceMiddleware } from './middleware/resource-middleware.js';
+import { hmrMiddleware } from './middleware/hmr-middleware.js';
+function initMiddleware(app, server, serverContext) {
+    // all middleware attached AFTER compression will have compressed responses
+    app.useCompression();
     localeMiddleware(app, serverContext);
-    apiMiddleware(app, serverContext);
-    uiMiddleware(app, serverContext);
+    moduleMiddleware(app, serverContext);
+    bundleMiddleware(app, serverContext);
+    mappingMiddleware(app, serverContext);
+    assetMiddleware(app, serverContext);
+    resourceMiddleware(app, serverContext);
+    // view middleware MUST be attached last because it contains a greedy middleware
+    // to handle unsupported routes
+    viewMiddleware(app, serverContext);
+    // initialize routes MUST be called when using koa
+    app.initRoutes();
+    // hmr uses web sockets, so it doesn't matter when this is attached
     if (serverContext.runtimeEnvironment.hmrEnabled) {
-        // setup hmr middleware
         hmrMiddleware(server, serverContext);
     }
 }
-async function initContext(app, server, rawAppConfig) {
-    const { appConfig, runtimeEnvironment, globalData } = await resolveConfigurations(rawAppConfig);
-    // Initialized PRIVATE server-side context, passed to middlewares
+function createServices(entries, providerContext) {
+    return entries.map(([ctor, providerConfig = {}]) => new ctor(providerConfig, providerContext));
+}
+async function initContext(appConfig, runtimeEnvironment, globalData) {
+    // load all hooks
+    const hooks = await loadHooks(appConfig);
+    // apply both config and on start hooks
+    if (hooks.length) {
+        const skipValidation = true; // skip for config hook, since `executeStartHooks` hook will validate
+        await executeConfigHooks(hooks, appConfig, runtimeEnvironment, globalData, skipValidation);
+        executeStartHooks(hooks, appConfig);
+    }
+    // load all configurable modules
+    const services = await loadServices(appConfig);
+    // create all framework components(ie. registries)
     const serverContext = createServerContext(appConfig, runtimeEnvironment, globalData);
+    // create public subset of configurations
     const providerContext = createProviderContext(serverContext);
-    const { moduleRegistry, resourceRegistry, viewRegistry, assetRegistry } = serverContext;
-    // Module Providers
-    const moduleProviders = await getServices(appConfig.moduleProviders, providerContext, appConfig);
+    const { moduleRegistry, assetRegistry, resourceRegistry, viewRegistry, moduleBundler } = serverContext;
+    // instantiate each service
+    const moduleProviders = createServices(services.moduleProviders, providerContext);
+    const assetProviders = createServices(services.assetProviders, providerContext);
+    const assetTransformers = createServices(services.assetTransformers, providerContext);
+    const resourceProviders = createServices(services.resourceProviders, providerContext);
+    const viewProviders = createServices(services.viewProviders, providerContext);
+    const viewTransformers = createServices(services.viewTransformers, providerContext);
+    const bundleProviders = createServices(services.bundleProviders, providerContext);
+    // add services to their corresponding registry
     moduleRegistry.addModuleProviders(moduleProviders);
-    // Resource Providers
-    const resourceProviders = await getServices(appConfig.resourceProviders, providerContext, appConfig);
+    assetRegistry.addAssetProviders(assetProviders);
+    assetRegistry.addAssetTransformers(assetTransformers);
     resourceRegistry.addResourceProviders(resourceProviders);
-    // View Providers
-    const viewProviders = await getServices(appConfig.viewProviders, providerContext, appConfig);
-    // View Transformers
-    const viewTransformers = await getServices(appConfig.viewTransformers, providerContext, rawAppConfig);
     viewRegistry.addViewProviders(viewProviders);
     viewRegistry.addViewTransformers(viewTransformers);
-    await viewRegistry.initializeViewProviders();
-    // Asset Providers
-    const assetProviders = await getServices(appConfig.assetProviders, providerContext, appConfig);
-    const assetTransformers = await getServices(appConfig.assetTransformers, undefined, appConfig);
-    assetRegistry.addAssetProviders(assetProviders);
-    assetRegistry.addAssetTransformers(assetTransformers);
+    moduleBundler.addBundleProviders(bundleProviders);
+    // invoke async initialization
+    await serverContext.viewRegistry.initializeViewProviders();
+    // set routes on server context
+    const routeHandlers = await loadRouteHandlers(appConfig);
+    serverContext.routeHandlers = routeHandlers;
     return serverContext;
 }
 export class LwrApp {
-    constructor(config) {
+    constructor(config = {}) {
         this.initialized = false;
-        this.config = normalizeConfig(config);
+        const { appConfig, runtimeEnvironment, globalData } = loadConfig(config);
+        this.config = appConfig;
+        this.runtimeEnvironment = runtimeEnvironment;
+        this.globalData = globalData;
         const { basePath } = this.config;
         this.app = createInternalServer(this.config.serverType, { basePath });
         this.server = this.app.createHttpServer();
     }
     setConfig(config) {
-        this.config = normalizeConfig(config);
+        const { appConfig, runtimeEnvironment, globalData } = loadConfig(config);
+        this.config = appConfig;
+        this.runtimeEnvironment = runtimeEnvironment;
+        this.globalData = globalData;
     }
     getConfig() {
         return this.config;
     }
     async init() {
-        if (!this.initialized) {
-            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;
-            }
+        if (this.initialized) {
+            return;
+        }
+        // preemptively mark the server as initialized
+        this.initialized = true;
+        try {
+            // create the application server context
+            const context = await initContext(this.config, this.runtimeEnvironment, this.globalData);
+            // attach framework middleware to the server
+            initMiddleware(this.app, this.server, context);
+        }
+        catch (e) {
+            // reset the initialized property if the server fails to initialize
+            this.initialized = false;
+            throw e;
         }
     }
     async listen(callback) {
@@ -136,7 +173,7 @@ export async function generateStaticSite(config) {
     const { serverMode } = config;
     if (serverMode === 'dev' || serverMode === 'compat') {
         // TODO: dynamic imports are not generated in dev mode
-        // https://github.com/salesforce/lwr/issues/1111
+        // https://github.com/salesforce-experience-platform-emu/lwr/issues/1111
         logger.warn('static generation in `dev` or `compat` mode is currently not fully supported');
     }
     const lwrApp = createServer(config);
@@ -146,7 +183,6 @@ export async function generateStaticSite(config) {
     await new SiteGenerator().buildStaticApplication(lwrApp.getConfig(), dispatcher);
     return lwrApp.getConfig();
 }
-export { buildServer } from './tools/server-build.js';
 /**
  * Create normalized config for static generation forcing the app config to come as src
  */

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

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

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

@@ -0,0 +1,42 @@
+import path from 'path';
+import { getAssetIdentity } from './utils/identity.js';
+import { handleErrors } from './utils/error-handling.js';
+function createAssetMiddleware(context) {
+    const { assetRegistry, runtimeEnvironment: { basePath }, } = context;
+    return async (req, res) => {
+        const { runtimeEnvironment } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { assetId, immutable, signature } = getAssetIdentity(req);
+        if (basePath && !assetId.specifier.startsWith(basePath)) {
+            assetId.specifier = path.join(basePath, assetId.specifier);
+        }
+        // Redirect if this is an external asset
+        const assetUri = await assetRegistry.resolveAssetUri(assetId, runtimeEnvironment);
+        if (assetUri.external) {
+            res.set({
+                Location: assetUri.uri,
+                'cache-control': 'public, max-age=60',
+            });
+            res.sendStatus(302);
+            return;
+        }
+        const asset = await assetRegistry.getAsset({ ...assetId, signature }, runtimeEnvironment, req.isSiteGeneration());
+        if (req.isSiteGeneration()) {
+            res.setSiteGenerationMetadata({ asset });
+        }
+        if (asset.mime) {
+            res.type(asset.mime);
+        }
+        if (runtimeEnvironment.immutableAssets && immutable) {
+            res.setHeader('Cache-control', 'public, max-age=12895706, immutable');
+        }
+        else if (runtimeEnvironment.immutableAssets) {
+            res.setHeader('Cache-control', 'public, max-age=60');
+        }
+        res.status(200).stream(asset.stream());
+    };
+}
+export function assetMiddleware(app, context) {
+    const paths = context.appConfig.assets.map((a) => a.urlPath + app.getRegexWildcard());
+    app.get([...paths, '/:apiVersion/:assetType/:immutable?/s/:signature/' + app.getRegexWildcard()], handleErrors(createAssetMiddleware(context)));
+}
+//# sourceMappingURL=asset-middleware.js.map

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

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

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

@@ -0,0 +1,88 @@
+import { LATEST_SIGNATURE } from '@lwrjs/shared-utils';
+import { descriptions } from '@lwrjs/diagnostics';
+import { getRequestImporter } from './utils/request.js';
+import { getModuleIdentity } from './utils/identity.js';
+import { normalizeResolvedUris } from './utils/metadata.js';
+import { createUnsignedBundleRedirect } from './redirects/unsigned-module-redirect.js';
+import { handleErrors } from './utils/error-handling.js';
+function createBundleMiddleware(context) {
+    const { moduleRegistry, moduleBundler } = context;
+    const unsignedBundleRedirect = createUnsignedBundleRedirect(moduleBundler);
+    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);
+        const importer = req.query.importer ? await getRequestImporter(req, moduleRegistry) : undefined;
+        const { moduleId, signature } = getModuleIdentity(req, importer);
+        if (moduleId.importer || !signature) {
+            await unsignedBundleRedirect(req, res, moduleId, runtimeEnvironment, runtimeParams);
+            return;
+        }
+        const sourceMapUrl = req.path.replace('/bundle/', '/sourcemaps/bundle/');
+        const bundleDefinition = await moduleBundler.getModuleBundle(moduleId, 
+        // bundle must be `true` to properly resolve bundles in amd
+        { ...runtimeEnvironment, bundle: true, sourceMapUrl }, runtimeParams);
+        if (req.isSiteGeneration()) {
+            res.setSiteGenerationMetadata({
+                moduleDefinition: bundleDefinition,
+                resolvedUris: await normalizeResolvedUris(bundleDefinition, runtimeEnvironment, runtimeParams, moduleBundler, moduleRegistry),
+            });
+        }
+        if (signature !== LATEST_SIGNATURE) {
+            res.setHeader('Cache-control', 'public, max-age=31536000, immutable');
+        }
+        res.status(200).type('application/javascript').send(bundleDefinition.code);
+    };
+}
+function createSourceMapMiddleware(context) {
+    const { moduleBundler } = context;
+    return async (req, res) => {
+        if (!req.validateEnvironmentRequest(context.appConfig)) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+            return;
+        }
+        const { runtimeEnvironment } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { moduleId, signature } = getModuleIdentity(req);
+        const bundleDef = await moduleBundler.getModuleBundle(moduleId, runtimeEnvironment);
+        if (signature !== LATEST_SIGNATURE) {
+            res.setHeader('Cache-control', 'public, max-age=31536000, immutable');
+        }
+        res.status(200).type('application/json').send(bundleDef.map);
+    };
+}
+export function bundleMiddleware(app, context) {
+    app.get([
+        `/:apiVersion/bundle/:format/:compat?/l/:locale/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/l/:locale/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/l/:locale/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/l/:locale/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/bundle/:format/:compat?/l/:locale/e/:environment/bi/:bundleSpecifier/module/mi/:specifier`,
+        `/:apiVersion/bundle/:format/:compat?/l/:locale/bi/:bundleSpecifier/module/mi/:specifier`,
+        `/:apiVersion/bundle/:format/:compat?/e/:environment/bi/:bundleSpecifier/module/mi/:specifier`,
+        `/:apiVersion/bundle/:format/:compat?/bi/:bundleSpecifier/module/mi/:specifier`,
+    ], handleErrors(createBundleMiddleware(context)));
+    app.get([
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/l/:locale/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/l/:locale/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/l/:locale/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/l/:locale/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/e/:environment/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/bi/:bundleSpecifier/module/mi/:specifier/latest/:prettyUrl?`,
+        `/:apiVersion/sourcemaps/bundle/:format/:compat?/bi/:bundleSpecifier/module/mi/:specifier/s/:signature/:prettyUrl?`,
+    ], handleErrors(createSourceMapMiddleware(context)));
+}
+//# sourceMappingURL=bundle-middleware.js.map

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import type { ServerContext } from '@lwrjs/types';
+import http from 'http';
+export declare function hmrMiddleware(server: http.Server, context: ServerContext): void;
+//# sourceMappingURL=hmr-middleware.d.ts.map

package/build/es/{middlewares → middleware}/hmr-middleware.js

@@ -1,6 +1,6 @@
 import { WebSocketServer } from 'ws';
 import { getCacheKeyFromJson } from '@lwrjs/shared-utils';
-import { getRequestProperties } from './utils.js';
+import { getRequestProperties } from './utils/request.js';
 let hmr;
 class Hmr {
     constructor(server, context) {
@@ -52,8 +52,8 @@ class Hmr {
             version,
         };
         const modulesCacheId = getCacheKeyFromJson({ format, compat, debug });
-        const newUri = moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature);
-        const oldUri = moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, 'latest');
+        const newUri = moduleRegistry.resolveModuleUriSync(moduleId, signature, runtimeEnvironment, runtimeParams);
+        const oldUri = moduleRegistry.resolveModuleUriSync(moduleId, 'latest', runtimeEnvironment, runtimeParams);
         if (this.connectedClients) {
             for (const [ws, cacheId] of this.connectedClients) {
                 if (cacheId === modulesCacheId) {
@@ -100,7 +100,7 @@ class Hmr {
         }
     }
 }
-export default function hmrMiddleware(server, context) {
+export function hmrMiddleware(server, context) {
     hmr = new Hmr(server, context);
     hmr.setupHotModuleReload();
 }

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

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

package/build/es/{middlewares → middleware}/locale-middleware.js

@@ -1,8 +1,9 @@
-export default function localeMiddleware(app, context) {
+export function localeMiddleware(app, context) {
     const { defaultLocale } = context.runtimeEnvironment;
     app.use(async (req, res, next) => {
         const langs = req.acceptsLanguages();
         req.locale = langs?.length > 0 ? langs[0] : defaultLocale;
+        // await is required when calling next to support koa
         await next();
     });
 }

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

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

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

@@ -0,0 +1,34 @@
+import { getImportMetadataMappings } from '@lwrjs/shared-utils';
+import { descriptions } from '@lwrjs/diagnostics';
+import { getMappingIdentity } from './utils/identity.js';
+import { handleErrors } from './utils/error-handling.js';
+function createMappingMiddleware(context) {
+    const { moduleBundler, moduleRegistry } = context;
+    return async (req, res) => {
+        if (!req.validateEnvironmentRequest(context.appConfig)) {
+            res.status(400);
+            res.send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+            return;
+        }
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { moduleIds } = getMappingIdentity(req);
+        const importMetadata = await getImportMetadataMappings(moduleIds, runtimeEnvironment, runtimeParams, moduleRegistry, moduleBundler);
+        if (req.isSiteGeneration()) {
+            res.setSiteGenerationMetadata({ importMetadata });
+        }
+        res.status(200).type('application/json').send(importMetadata);
+    };
+}
+export 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`,
+    ], handleErrors(createMappingMiddleware(context)));
+}
+//# sourceMappingURL=mapping-middleware.js.map

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

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

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

@@ -0,0 +1,64 @@
+import { descriptions } from '@lwrjs/diagnostics';
+import { LATEST_SIGNATURE, serializeModuleToJson } from '@lwrjs/shared-utils';
+import { getRequestImporter } from './utils/request.js';
+import { getModuleIdentity } from './utils/identity.js';
+import { createUnsignedModuleRedirect } from './redirects/unsigned-module-redirect.js';
+import { handleErrors } from './utils/error-handling.js';
+function createModuleMiddleware(context) {
+    const { moduleRegistry } = context;
+    const unsignedRedirect = createUnsignedModuleRedirect(moduleRegistry);
+    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);
+        const importer = req.query.importer ? await getRequestImporter(req, moduleRegistry) : undefined;
+        const { moduleId, signature } = getModuleIdentity(req, importer);
+        if (moduleId.importer || !signature) {
+            await unsignedRedirect(req, res, moduleId, runtimeEnvironment, runtimeParams);
+            return;
+        }
+        const moduleDefinition = await moduleRegistry.getLinkedModule(moduleId, 
+        // bundle must be `false` to resolve amd modules in `prod-compat` mode
+        { ...runtimeEnvironment, bundle: false }, runtimeParams);
+        const { ownHash, linkedSource } = moduleDefinition;
+        // validate the requested instances exists
+        if (signature !== LATEST_SIGNATURE && ownHash !== signature) {
+            res.status(404).send(descriptions.UNRESOLVABLE.SIGNED_MODULE(moduleId.specifier, signature).message);
+            return;
+        }
+        if (req.isSiteGeneration()) {
+            res.setSiteGenerationMetadata({ moduleDefinition });
+        }
+        if (req.isJsonRequest()) {
+            const json = await serializeModuleToJson(linkedSource, moduleDefinition, moduleRegistry, runtimeParams);
+            res.status(200).type('application/json').send(json);
+            return;
+        }
+        res.status(200).type('application/javascript').send(linkedSource);
+    };
+}
+export 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`,
+    ], handleErrors(createModuleMiddleware(context)));
+}
+//# sourceMappingURL=module-middleware.js.map

package/build/es/middleware/redirects/unsigned-module-redirect.d.ts

@@ -0,0 +1,6 @@
+import type { AbstractModuleId, MiddlewareRequest, MiddlewareResponse, ModuleBundler, ModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+declare type UnsignedRedirect = (req: MiddlewareRequest, res: MiddlewareResponse, moduleId: AbstractModuleId, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams) => Promise<void>;
+export declare function createUnsignedModuleRedirect(moduleRegistry: ModuleRegistry): UnsignedRedirect;
+export declare function createUnsignedBundleRedirect(moduleBundler: ModuleBundler): UnsignedRedirect;
+export {};
+//# sourceMappingURL=unsigned-module-redirect.d.ts.map

package/build/es/middleware/redirects/unsigned-module-redirect.js

@@ -0,0 +1,25 @@
+const HEADER_LOCATION = 'Location';
+const STATUS_FOUND = 302;
+export 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}`);
+    };
+}
+export 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);
+}
+//# sourceMappingURL=unsigned-module-redirect.js.map

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

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

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

@@ -0,0 +1,37 @@
+import { descriptions } from '@lwrjs/diagnostics';
+import { getResourceIdentity } from './utils/identity.js';
+import { handleErrors } from './utils/error-handling.js';
+function createResourceMiddleware(context) {
+    const { resourceRegistry } = context;
+    return async (req, res) => {
+        if (!req.validateEnvironmentRequest(context.appConfig)) {
+            res.status(400).send(descriptions.UNRESOLVABLE.INVALID_ENVIRONMENT(req.params.environment).message);
+            return;
+        }
+        const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
+        const { resourceId } = 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(descriptions.UNRESOLVABLE.RESOURCE(resourceId.specifier).message);
+    };
+}
+export 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?`,
+    ], handleErrors(createResourceMiddleware(context)));
+}
+//# sourceMappingURL=resource-middleware.js.map

package/build/es/middleware/utils/error-handling.d.ts

@@ -0,0 +1,3 @@
+import { MiddlewareFunction } from '@lwrjs/types';
+export declare function handleErrors(middleware: MiddlewareFunction): MiddlewareFunction;
+//# sourceMappingURL=error-handling.d.ts.map

package/build/es/middleware/utils/error-handling.js

@@ -0,0 +1,32 @@
+import { descriptions, DiagnosticsError, LwrUnresolvableError } from '@lwrjs/diagnostics';
+function createReturnStatus(error, url) {
+    if (error instanceof LwrUnresolvableError &&
+        error.diagnostics[0].description.category === 'lwrUnresolvable/invalid') {
+        return { status: 400, message: error.message };
+    }
+    if (error instanceof LwrUnresolvableError) {
+        return { status: 404, message: error.message };
+    }
+    return { status: 500, message: descriptions.UNRESOLVABLE.SERVER_ERROR(url).message };
+}
+export function handleErrors(middleware) {
+    return async (req, res, next) => {
+        try {
+            await middleware(req, res, next);
+        }
+        catch (err) {
+            if (err instanceof 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);
+        }
+    };
+}
+//# sourceMappingURL=error-handling.js.map

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

@@ -0,0 +1,6 @@
+import type { AssetIdentity, MappingIdentity, MiddlewareRequest, ModuleIdentity, ResourceIdentity } from '@lwrjs/types';
+export declare function getModuleIdentity(req: MiddlewareRequest, importer?: string): ModuleIdentity;
+export declare function getMappingIdentity(req: MiddlewareRequest): MappingIdentity;
+export declare function getResourceIdentity(req: MiddlewareRequest): ResourceIdentity;
+export declare function getAssetIdentity(req: MiddlewareRequest): AssetIdentity;
+//# sourceMappingURL=identity.d.ts.map