@lwrjs/core 0.9.0-alpha.3 → 0.9.0-alpha.30

package/build/es/index.js

@@ -1,178 +1,117 @@
-import { deepFreeze, getFeatureFlags, DEFAULT_LWR_BOOTSTRAP_CONFIG, logger } 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 '@lwrjs/config';
-import { LwrApplicationObserver } from '@lwrjs/shared-utils';
-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 { getGlobalData } from './context/global-data.js';
-import { runConfigurationsHook } from './context/hooks.js';
-import baseMiddleware from './middlewares/base-middleware.js';
+import { getFeatureFlags, DEFAULT_LWR_BOOTSTRAP_CONFIG, logger } from '@lwrjs/shared-utils';
 import { createInternalServer } from '@lwrjs/server';
-import { getServiceModule } from './context/services.js';
+import { LwrServerError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
+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';
-// Parse the service constructors and instantiate them
-async function getServices(services, providerContext, lwrConfig) {
-    return Promise.all(services.map(async (serviceEntry) => {
-        const [serviceName, serviceConfig = {}] = Array.isArray(serviceEntry)
-            ? serviceEntry
-            : [serviceEntry];
-        const ServiceCtor = await getServiceModule(serviceName, lwrConfig);
-        return new ServiceCtor(serviceConfig, providerContext);
-    }));
-}
-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, rawLwrConfig) {
-    const { apiVersion, basePath, lwrVersion, serverMode, globalDataDir, globalData } = rawLwrConfig;
-    const rawDataConfig = getGlobalData(globalDataDir, globalData);
-    const rawRuntimeEnvConfig = {
-        ...explodeMode(serverMode),
-        apiVersion,
-        basePath,
-        lwrVersion,
-        debug: false,
-        serverMode,
-        featureFlags: getFeatureFlags(),
-    };
-    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,
-    }, lwrConfig);
-    const moduleRegistry = new LwrModuleRegistry({
-        compiler,
-        appObserver,
-        appEmitter,
-        runtimeEnvironment: runtimeConfig,
-    }, lwrConfig);
-    const moduleBundler = new LwrModuleBundler({ compiler, moduleRegistry, appObserver }, lwrConfig);
-    const resourceRegistry = new LwrResourceRegistry();
-    const viewRegistry = new LwrViewRegistry({
-        moduleRegistry,
-        moduleBundler,
-        resourceRegistry,
-        assetRegistry,
-        appObserver,
-        appEmitter,
-        globalData: dataConfig,
-        runtimeEnvironment: runtimeConfig,
-    }, lwrConfig);
-    // Initialized PRIVATE server-side context, passed to middlewares
-    const serverContext = {
-        compiler,
-        server,
-        appObserver,
-        appEmitter,
-        moduleRegistry,
-        moduleBundler,
-        resourceRegistry,
-        assetRegistry,
-        viewRegistry,
-        appConfig: lwrConfig,
-        runtimeEnvironment: runtimeConfig,
-    };
-    // This is a subset of config to user-land code
-    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 = {
-        compiler,
-        appObserver: deepFreeze({ onModuleDefinitionChange, onModuleSourceChange }),
-        appEmitter: {
-            notifyModuleDefinitionChanged: (payload) => notifyModuleDefinitionChanged.call(appEmitter, payload),
-            notifyModuleSourceChanged: (payload) => notifyModuleSourceChanged.call(appEmitter, payload),
-            notifyViewSourceChanged: (payload) => notifyViewSourceChanged.call(appEmitter, payload),
-            notifyAssetSourceChanged: (payload) => notifyAssetSourceChanged.call(appEmitter, payload),
-        },
-        moduleRegistry: moduleRegistry.getPublicApi(),
-        moduleBundler: moduleBundler,
-        resourceRegistry: resourceRegistry.getPublicApi(),
-        viewRegistry: viewRegistry.getPublicApi(),
-        assetRegistry: assetRegistry.getPublicApi(),
-        config: deepFreeze({
-            cacheDir,
-            modules,
-            routes,
-            errorRoutes,
-            rootDir,
-            basePath,
-            contentDir,
-            layoutsDir,
-            locker,
-            amdLoader,
-            esmLoader,
-            environment,
-        }),
-        runtimeEnvironment: deepFreeze(runtimeConfig),
-    };
-    // Module Providers
-    const moduleProviders = await getServices(lwrConfig.moduleProviders, providerContext, lwrConfig);
+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, 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(lwrConfig.resourceProviders, providerContext, lwrConfig);
+    assetRegistry.addAssetProviders(assetProviders);
+    assetRegistry.addAssetTransformers(assetTransformers);
     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);
-    assetRegistry.addAssetProviders(assetProviders);
+    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) {
@@ -234,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);

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