@lwrjs/core 0.9.0-alpha.11 → 0.9.0-alpha.13

package/build/es/index.js

@@ -1,13 +1,11 @@
 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 { 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, normalizeConfig, loadServices, loadRoutes } from '@lwrjs/config';
 import SiteGenerator from './tools/static-generation.js';
 import { warmupServer } from './tools/server-warmup.js';
+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';
@@ -16,7 +14,7 @@ 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) {
+function initMiddleware(app, server, serverContext, routes, errorRoutes) {
     // all middleware attached AFTER compression will have compressed responses
     app.useCompression();
     localeMiddleware(app, serverContext);
@@ -27,7 +25,7 @@ function initMiddleware(app, server, serverContext) {
     resourceMiddleware(app, serverContext);
     // view middleware MUST be attached last because it contains a greedy middleware
     // to handle unsupported routes
-    viewMiddleware(app, serverContext);
+    viewMiddleware(app, serverContext, routes, errorRoutes);
     // initialize routes MUST be called when using koa
     app.initRoutes();
     // hmr uses web sockets, so it doesn't matter when this is attached
@@ -35,28 +33,30 @@ function initMiddleware(app, server, serverContext) {
         hmrMiddleware(server, serverContext);
     }
 }
-async function initContext(app, server, rawAppConfig) {
-    const { appConfig, runtimeEnvironment, globalData } = await resolveConfigurations(rawAppConfig);
+function createServices(entries, providerContext) {
+    return entries.map(([ctor, providerConfig = {}]) => new ctor(providerConfig, providerContext));
+}
+async function initContext(appConfig, runtimeEnvironment, globalData, services) {
     // Initialized PRIVATE server-side context, passed to middleware
     const serverContext = createServerContext(appConfig, runtimeEnvironment, globalData);
     const providerContext = createProviderContext(serverContext);
     const { moduleRegistry, resourceRegistry, viewRegistry, assetRegistry } = serverContext;
     // Module Providers
-    const moduleProviders = await getServices(appConfig.moduleProviders, providerContext, appConfig);
+    const moduleProviders = createServices(services.moduleProviders, providerContext);
     moduleRegistry.addModuleProviders(moduleProviders);
     // Resource Providers
-    const resourceProviders = await getServices(appConfig.resourceProviders, providerContext, appConfig);
+    const resourceProviders = await createServices(services.resourceProviders, providerContext);
     resourceRegistry.addResourceProviders(resourceProviders);
     // View Providers
-    const viewProviders = await getServices(appConfig.viewProviders, providerContext, appConfig);
+    const viewProviders = await createServices(services.viewProviders, providerContext);
     // View Transformers
-    const viewTransformers = await getServices(appConfig.viewTransformers, providerContext, rawAppConfig);
+    const viewTransformers = await createServices(services.viewTransformers, providerContext);
     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);
+    const assetProviders = await createServices(services.assetProviders, providerContext);
+    const assetTransformers = await createServices(services.assetTransformers, providerContext);
     assetRegistry.addAssetProviders(assetProviders);
     assetRegistry.addAssetTransformers(assetTransformers);
     return serverContext;
@@ -76,16 +76,27 @@ export class LwrApp {
         return this.config;
     }
     async init() {
-        if (!this.initialized) {
-            this.initialized = true;
-            try {
-                const context = await initContext(this.app, this.server, this.config);
-                initMiddleware(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 {
+            // load and process all application configurations, services, and routes
+            const { appConfig, runtimeEnvironment, globalData } = await loadConfig(this.config);
+            const services = await loadServices(appConfig);
+            const { routes, errorRoutes } = await loadRoutes(appConfig);
+            // create the application server context
+            const context = await initContext(appConfig, runtimeEnvironment, globalData, services);
+            // attach framework middleware to the server
+            initMiddleware(this.app, this.server, context, routes, errorRoutes);
+            // expose the normalized config after config hooks are applied
+            this.config = appConfig;
+        }
+        catch (e) {
+            // reset the initialized property if the server fails to initialize
+            this.initialized = false;
+            throw e;
         }
     }
     async listen(callback) {

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

@@ -27,8 +27,9 @@ function createBundleMiddleware(context) {
             return;
         }
         const sourceMapUrl = req.path.replace('/bundle/', '/sourcemaps/bundle/');
-        const sourceMapRuntimeContext = { ...runtimeEnvironment, sourceMapUrl };
-        const bundleDefinition = await moduleBundler.getModuleBundle(moduleId, sourceMapRuntimeContext, runtimeParams);
+        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,

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

@@ -25,7 +25,9 @@ function createModuleMiddleware(context) {
             await unsignedRedirect(req, res, moduleId, runtimeEnvironment, runtimeParams);
             return;
         }
-        const moduleDefinition = await moduleRegistry.getLinkedModule(moduleId, runtimeEnvironment, runtimeParams);
+        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) {

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

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

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

@@ -9,9 +9,8 @@ const CANONICAL_VIEW_ROUTES = [
     `/:apiVersion/application/:format/ai/:appId`,
     `/:apiVersion/application/:format/e/:environment/ai/:appId`,
 ];
-function createViewMiddleware(route, context, viewHandler) {
-    const { appConfig } = context;
-    const errorRoute = appConfig.errorRoutes.find((route) => route.status === 500);
+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);
@@ -68,9 +67,7 @@ function createViewMiddleware(route, context, viewHandler) {
         res.send(viewResponse.body);
     };
 }
-function createConfigMiddleware(context, viewHandler) {
-    const { appConfig } = context;
-    const { routes } = appConfig;
+function createConfigMiddleware(routes, context, viewHandler) {
     return async (req, res) => {
         const { runtimeEnvironment, runtimeParams } = req.getRuntimeContext(context.runtimeEnvironment);
         const { appId, encodedViewPath } = req.params;
@@ -106,21 +103,20 @@ function createConfigMiddleware(context, viewHandler) {
         res.send(viewResponse.body);
     };
 }
-function createNotFoundMiddleware(context, viewHandler) {
-    const { errorRoutes } = context.appConfig;
-    const errorRoute = errorRoutes.find((route) => route.status === 404);
-    if (errorRoute) {
-        return createViewMiddleware(errorRoute, context, viewHandler);
+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) {
+export function viewMiddleware(app, context, routes, errorRoutes) {
     const { appConfig, viewRegistry, moduleRegistry } = context;
     const viewHandler = new LwrViewHandler({ viewRegistry, moduleRegistry }, appConfig);
     // create and attach middleware for each route
-    for (const route of appConfig.routes) {
+    for (const route of routes) {
         const paths = [route.path];
         const subRoutes = route.subRoutes && getClientRoutes(route.subRoutes);
         if (subRoutes) {
@@ -128,12 +124,12 @@ export function viewMiddleware(app, context) {
             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, context, viewHandler)));
+        app.get(paths, handleErrors(createViewMiddleware(route, errorRoutes, context, viewHandler)));
     }
     // create and attach middleware for bootstrap configurations
-    app.get(getClientBootstrapConfigurationRoutes(), handleErrors(createConfigMiddleware(context, viewHandler)));
+    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(context, viewHandler)));
+    app.get('/' + app.getRegexWildcard(), handleErrors(createNotFoundMiddleware(errorRoutes, context, viewHandler)));
 }
 //# sourceMappingURL=view-middleware.js.map

package/build/es/tools/plugins/build-server-plugin.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from 'esbuild';
+import type { LwrGlobalConfig } from '@lwrjs/types';
+/**
+ * Creates an esbuild plugin that generates a server build module
+ *
+ * @remarks
+ * The generated server build module contains:
+ * - normalized lwr global config(without normalized directories and after config hooks are applied)
+ * - runtime environment(after config hooks are applied)
+ * - global data(after config hooks are applied)
+ * - lwr services(ie. module providers) with static imports
+ * - route handlers with static imports
+ *
+ * @param config - programmatic global config
+ * @returns esbuild plugin
+ */
+export default function buildLwrServer(config?: LwrGlobalConfig): Plugin;
+//# sourceMappingURL=build-server-plugin.d.ts.map

package/build/es/tools/plugins/build-server-plugin.js

@@ -0,0 +1,132 @@
+import path from 'path';
+import { loadConfig } from '@lwrjs/config';
+import { normalizeDirectory } from '@lwrjs/shared-utils';
+const services = [
+    'moduleProviders',
+    'assetProviders',
+    'assetTransformers',
+    'viewProviders',
+    'viewTransformers',
+    'resourceProviders',
+];
+function processServices(kind, entries, rootDir) {
+    const output = {
+        imports: [],
+        entries: [],
+    };
+    for (const [index, [entry, config]] of entries.entries()) {
+        const name = kind + index;
+        output.imports.push(`import ${name} from '${normalizeDirectory(entry, rootDir)}';`);
+        output.entries.push([name, config]);
+    }
+    return output;
+}
+function processRoutes(routes, rootDir) {
+    const output = {
+        imports: [],
+        routes: [],
+    };
+    const handlers = {};
+    for (const route of routes) {
+        if (!route.routeHandler) {
+            output.routes.push(route);
+            continue;
+        }
+        const handler = route.routeHandler;
+        if (!handlers[handler]) {
+            const name = `routeHandler${Object.keys(handlers).length}`;
+            handlers[handler] = name;
+            output.imports.push(`import ${name} from '${normalizeDirectory(handler, rootDir)}';`);
+        }
+        output.routes.push({
+            ...route,
+            routeHandler: handlers[handler],
+        });
+    }
+    return output;
+}
+function printServices(config) {
+    return `{${Object.entries(config)
+        .map(([key, value]) => {
+        const entries = value;
+        return `${key}: [${entries.map(([ctor, config = {}]) => `[${ctor}, ${JSON.stringify(config)}]`)}]`;
+    })
+        .join(',')}}`;
+}
+function printRoutes(routes) {
+    return `[${routes
+        .map((route) => {
+        return `{${Object.entries(route)
+            .map(([key, value]) => {
+            if (key !== 'routeHandler') {
+                return `${key}: ${JSON.stringify(value)}`;
+            }
+            return `${key}: ${value}`;
+        })
+            .join(',')}}`;
+    })
+        .join(',')}]`;
+}
+/**
+ * Creates an esbuild plugin that generates a server build module
+ *
+ * @remarks
+ * The generated server build module contains:
+ * - normalized lwr global config(without normalized directories and after config hooks are applied)
+ * - runtime environment(after config hooks are applied)
+ * - global data(after config hooks are applied)
+ * - lwr services(ie. module providers) with static imports
+ * - route handlers with static imports
+ *
+ * @param config - programmatic global config
+ * @returns esbuild plugin
+ */
+export default function buildLwrServer(config) {
+    return {
+        name: 'lwr-server-build',
+        setup(build) {
+            // This file is generated during the build, so it is mapped to a custom namespace
+            // to prevent looking for it on the file system.
+            build.onResolve({ filter: /.*\/lwr.build.js$/ }, (args) => ({
+                path: args.path,
+                namespace: 'lwr-server-build',
+            }));
+            build.onLoad({ filter: /.*/, namespace: 'lwr-server-build' }, async (args) => {
+                const { appConfig, runtimeEnvironment, globalData } = await loadConfig(config, {
+                    skipDirNormalization: true,
+                });
+                const remoteAppConfig = {
+                    ...appConfig,
+                    ignoreLwrConfigFile: true,
+                    rootDir: undefined,
+                    port: undefined,
+                };
+                const serviceImports = [];
+                const serviceConfig = {};
+                for (const service of services) {
+                    const entries = processServices(service, appConfig[service], appConfig.rootDir);
+                    serviceImports.push(...entries.imports);
+                    serviceConfig[service] = entries.entries;
+                }
+                const routesConfig = processRoutes(appConfig.routes, appConfig.rootDir);
+                const errorRoutesConfig = processRoutes(appConfig.errorRoutes, appConfig.rootDir);
+                return {
+                    contents: [
+                        ...serviceImports,
+                        ...routesConfig.imports,
+                        ...errorRoutesConfig.imports,
+                        `export const appConfig = ${JSON.stringify(remoteAppConfig)};`,
+                        `export const runtimeEnvironment = ${JSON.stringify(runtimeEnvironment)};`,
+                        `export const globalData = ${JSON.stringify(globalData)};`,
+                        `export const services = ${printServices(serviceConfig)};`,
+                        `export const routes = ${printRoutes(routesConfig.routes)};`,
+                        `export const errorRoutes = ${printRoutes(errorRoutesConfig.routes)};`,
+                    ].join('\n'),
+                    loader: 'ts',
+                    resolveDir: path.dirname(args.path),
+                };
+            });
+        },
+    };
+}
+//# sourceMappingURL=build-server-plugin.js.map

package/build/es/tools/plugins/generate-entry-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'esbuild';
+/**
+ * Creates an esbuild plugin that generates the application entry point
+ *
+ * @remarks
+ * The generated entry point includes a reference to a generated server build module.
+ *
+ * @returns esbuild plugin
+ */
+export default function generateLwrEntry(): Plugin;
+//# sourceMappingURL=generate-entry-plugin.d.ts.map

package/build/es/tools/plugins/generate-entry-plugin.js

@@ -0,0 +1,45 @@
+import path from 'path';
+/**
+ * Creates an esbuild plugin that generates the application entry point
+ *
+ * @remarks
+ * The generated entry point includes a reference to a generated server build module.
+ *
+ * @returns esbuild plugin
+ */
+export default function generateLwrEntry() {
+    return {
+        name: 'lwr-entry',
+        setup(build) {
+            // This file is generated during the build, so it is mapped to a custom namespace
+            // to prevent looking for it on the file system.
+            build.onResolve({ filter: /.*\/lwr.entry.js$/ }, ({ kind, path }) => {
+                if (kind === 'entry-point') {
+                    return {
+                        path,
+                        namespace: 'lwr-entry',
+                    };
+                }
+            });
+            build.onLoad({ filter: /.*/, namespace: 'lwr-entry' }, (args) => ({
+                contents: [
+                    `/* This module is generated */`,
+                    `import { createHandler } from '@lwrjs/lambda';`,
+                    // Importing the server build module at this point enables support for ESM bundling.
+                    // If the server build module was imported in `createHandler`, it would need to be exposed
+                    // as CJS.
+                    `import * as build from './lwr.build.js';`,
+                    // The server build module MUST NOT require asynchronous initialization to support running on MRT
+                    // Once MRT supports ESM, top-level await could be used at this point to perform some asynchronous
+                    // initialization.
+                    `const handler = createHandler(build);`,
+                    // MRT expects the handler to be a named export: `get`
+                    `export { handler as get };`,
+                ].join('\n'),
+                loader: 'ts',
+                resolveDir: path.dirname(args.path),
+            }));
+        },
+    };
+}
+//# sourceMappingURL=generate-entry-plugin.js.map

package/build/es/tools/server-build.d.ts

@@ -1,14 +1,13 @@
-import { LwrGlobalConfig } from '@lwrjs/types';
+import type { LwrGlobalConfig } from '@lwrjs/types';
 export interface BuildOptions {
-    target?: string;
     outputDir?: string;
 }
 /**
- * Resolve application configurations, generate a server context module, and bundle
- * the LWR server.  The bundled server will be written to the filesystem.
+ * Resolve configurations, generate a server build module, and bundle
+ * the LWR server.  The bundled server will be written to the file system.
  *
- * @param {LwrGlobalConfig} configArg - programmatic LWR application config
- * @param {BuildOptions} options - server build configurations
+ * @param {LwrGlobalConfig} configArg - programmatic LWR global config
+ * @param {BuildOptions} options - server build options
  */
 export declare function buildServer(configArg?: LwrGlobalConfig, options?: BuildOptions): Promise<void>;
 //# sourceMappingURL=server-build.d.ts.map

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

@@ -1,135 +1,18 @@
 import path from 'path';
 import fs from 'fs-extra';
 import esbuild from 'esbuild';
-import { normalizeConfig } from '@lwrjs/config';
-import { resolveConfigurations } from '../context/configurations.js';
-import { createProviderContext } from '../context/provider.js';
-import { createServerContext } from '../context/server.js';
-function getBuildMetadata(appConfig) {
-    const moduleProviders = processServiceEntries('moduleProvider', appConfig.moduleProviders);
-    const resourceProviders = processServiceEntries('resourceProvider', appConfig.resourceProviders);
-    const viewProviders = processServiceEntries('viewProvider', appConfig.viewProviders);
-    const viewTransformers = processServiceEntries('viewTransformer', appConfig.viewTransformers);
-    const assetProviders = processServiceEntries('assetProvider', appConfig.assetProviders);
-    const assetTransformers = processServiceEntries('assetTransformer', appConfig.assetTransformers);
-    const imports = [
-        ...moduleProviders.imports,
-        ...resourceProviders.imports,
-        ...viewProviders.imports,
-        ...viewTransformers.imports,
-        ...assetProviders.imports,
-        ...assetTransformers.imports,
-    ];
-    return {
-        imports,
-        moduleProviders: moduleProviders.services,
-        resourceProviders: resourceProviders.services,
-        viewProviders: viewProviders.services,
-        viewTransformers: viewTransformers.services,
-        assetProviders: assetProviders.services,
-        assetTransformers: assetTransformers.services,
-    };
-}
-function processServiceEntries(serviceType, entries) {
-    const imports = [];
-    const services = [];
-    for (const [index, [pkg, config]] of entries.entries()) {
-        const name = serviceType + index;
-        imports.push(`import ${name} from '${pkg}';`);
-        services.push(`[${name}, ${JSON.stringify(config)}]`);
-    }
-    return {
-        imports,
-        services,
-    };
-}
-function generateServices(providerContext) {
-    return ([ServiceCtor, serviceConfig = {}]) => new ServiceCtor(serviceConfig, providerContext);
-}
-function isRemote() {
-    return process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined;
-}
-function generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata) {
-    const { imports, moduleProviders, resourceProviders, viewProviders, viewTransformers, assetProviders, assetTransformers, } = metadata;
-    // config will be resolved programmatically and relative to the current machine
-    const config = {
-        ...appConfig,
-        rootDir: undefined,
-        ignoreLwrConfigFile: true,
-    };
-    return [
-        `/* This module is generated */`,
-        `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 { LwrApplicationObserver, deepFreeze } from '@lwrjs/shared-utils';`,
-        `import { normalizeConfig } from '@lwrjs/config';`,
-        // all of the static imports for the services
-        ...imports,
-        // reusing context resolution utils
-        createServerContext.toString(),
-        createProviderContext.toString(),
-        // helper function for generically initializing the services
-        generateServices.toString(),
-        // helper function to check if running on lambda
-        isRemote.toString(),
-        `const config = ${JSON.stringify(config, null, 4)}`,
-        `const runtimeEnvironment = ${JSON.stringify(runtimeEnvironment, null, 4)}`,
-        `const globalData = ${JSON.stringify(globalData, null, 4)}`,
-        // build artifacts are placed into a build dir on MRT
-        `isRemote() && process.chdir(__dirname);`,
-        `isRemote() && (config.rootDir = __dirname);`,
-        // cache dir must be in tmp dir to be able to write to the filesystem on lambda
-        `isRemote() && (config.cacheDir = '/tmp/__lwr_cache__');`,
-        // resolve all config config paths relative to the current machine
-        `const normalizedConfig = normalizeConfig(config);`,
-        `const serverContext = createServerContext(normalizedConfig, runtimeEnvironment, globalData);`,
-        `const providerContext = createProviderContext(serverContext);`,
-        `const generate = generateServices(providerContext);`,
-        `const moduleProviders = [${moduleProviders}].map(generate);`,
-        `const resourceProviders = [${resourceProviders}].map(generate);`,
-        `const viewProviders = [${viewProviders}].map(generate);`,
-        `const viewTransformers = [${viewTransformers}].map(generate);`,
-        `const assetProviders = [${assetProviders}].map(generate);`,
-        `const assetTransformers = [${assetTransformers}].map(generate);`,
-        `serverContext.moduleRegistry.addModuleProviders(moduleProviders);`,
-        `serverContext.resourceRegistry.addResourceProviders(resourceProviders);`,
-        `serverContext.viewRegistry.addViewProviders(viewProviders);`,
-        `serverContext.viewRegistry.addViewTransformers(viewTransformers);`,
-        `serverContext.assetRegistry.addAssetProviders(assetProviders);`,
-        `serverContext.assetRegistry.addAssetTransformers(assetTransformers);`,
-        `export default serverContext;`,
-    ].join('\n');
-}
-function generateServerSource(target) {
-    // `lambda` is the only supported build target for now
-    if (target !== 'lambda') {
-        // TODO: move to diagnostic error
-        throw `Unsupported server build target: ${target}`;
-    }
-    return [
-        `/* This module is generated */`,
-        `import { createHandler } from '@lwrjs/lambda';`,
-        // Importing the server context module at this point enables support for ESM bundling.
-        // If the server context module was imported in `createHandler`, it would need to be exposed
-        // as CJS.
-        `import build from './lwr.build.js';`,
-        // The server context module MUST NOT require asynchronous initialization to support running on MRT
-        // Once MRT supports ESM, top-level await could be used at this point to perform some asynchronous
-        // initialization.
-        `const handler = createHandler(build);`,
-        // MRT expects the handler to be a named export: `get`
-        `export { handler as get };`,
-    ].join('\n');
-}
-async function bundleServer(entryPoint, outputPath) {
+import { logger } from '@lwrjs/shared-utils';
+import { LWR_VERSION } from '@lwrjs/config';
+import generateLwrEntry from './plugins/generate-entry-plugin.js';
+import buildLwrServer from './plugins/build-server-plugin.js';
+async function build(outputDir, config) {
+    // building specifically for MRT/Lambda
     await esbuild.build({
-        entryPoints: [entryPoint],
+        entryPoints: ['./lwr.entry.js'],
         bundle: true,
         sourcemap: true,
+        format: 'cjs',
+        platform: 'node',
         logLevel: 'silent',
         external: [
             // issues with native dependencies
@@ -143,40 +26,27 @@ async function bundleServer(entryPoint, outputPath) {
             'rollup',
             'rollup-plugin-node-polyfills',
             // issues resolving relative files after bundling
-            '@lwrjs/config',
             '@lwrjs/loader',
         ],
-        format: 'cjs',
-        platform: 'node',
-        outfile: outputPath,
+        banner: {
+            js: `globalThis.LWR_VERSION='${LWR_VERSION};'`,
+        },
+        plugins: [generateLwrEntry(), buildLwrServer(config)],
+        // MRT expects an entry point named `ssr.js`
+        outfile: path.join(outputDir, 'ssr.js'),
     });
 }
 /**
- * Resolve application configurations, generate a server context module, and bundle
- * the LWR server.  The bundled server will be written to the filesystem.
+ * Resolve configurations, generate a server build module, and bundle
+ * the LWR server.  The bundled server will be written to the file system.
  *
- * @param {LwrGlobalConfig} configArg - programmatic LWR application config
- * @param {BuildOptions} options - server build configurations
+ * @param {LwrGlobalConfig} configArg - programmatic LWR global config
+ * @param {BuildOptions} options - server build options
  */
 export async function buildServer(configArg, options) {
-    // App config will be included in the generated server context module, but all of the config paths
-    // will not be normalized.  The config paths will be normalized at runtime to enable running the
-    // application on a different machine.
-    const config = normalizeConfig(configArg, { skipDirNormalization: true, skipCacheDirCreation: true });
-    // Config hooks are applied during generation because they enable asynchronous modification of
-    // the LWR configurations.  Since config hooks are run at build time, the config hooks MUST NOT be
-    // responsible for critical application initialization or have dependencies on normalized config paths.
-    const { appConfig, runtimeEnvironment, globalData } = await resolveConfigurations(config);
-    // All LWR services are processed and included in the generated server context module.  This module will
-    // statically import the services and initialize all LWR server components(ie. providers and registries).
-    const metadata = getBuildMetadata(appConfig);
-    const serverContext = generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata);
-    const outputDir = path.join(appConfig.rootDir, options?.outputDir || '/build');
-    const serverSource = generateServerSource(options?.target || 'lambda');
-    // HACK: writing the server context module and server entry to a file for debugging
+    const outputDir = path.join(configArg?.rootDir || process.cwd(), options?.outputDir || '/build');
     await fs.ensureDir(outputDir);
-    await fs.writeFile(path.join(outputDir, 'lwr.build.js'), serverContext);
-    await fs.writeFile(path.join(outputDir, 'entry.js'), serverSource);
-    await bundleServer(path.join(outputDir, 'entry.js'), path.join(outputDir, 'ssr.js'));
+    await build(outputDir, configArg);
+    logger.info('Successfully built the server');
 }
 //# sourceMappingURL=server-build.js.map