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

package/build/cjs/context/provider.cjs

@@ -77,6 +77,7 @@ function createProviderContext(serverContext) {
       esmLoader,
       environment
     }),
-    runtimeEnvironment: (0, import_shared_utils.deepFreeze)(serverContext.runtimeEnvironment)
+    runtimeEnvironment: (0, import_shared_utils.deepFreeze)(serverContext.runtimeEnvironment),
+    watcherFactory: serverContext.watcherFactory
   };
 }

package/build/cjs/context/server.cjs

@@ -33,6 +33,7 @@ var import_module_registry = __toModule(require("@lwrjs/module-registry"));
 var import_resource_registry = __toModule(require("@lwrjs/resource-registry"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_view_registry = __toModule(require("@lwrjs/view-registry"));
+var import_fs_watch = __toModule(require("@lwrjs/shared-utils/fs-watch"));
 function createServerContext(appConfig, runtimeEnvironment, globalData) {
   const appObserver = new import_shared_utils.LwrApplicationObserver();
   const appEmitter = appObserver.createLwrEmitter();
@@ -60,6 +61,7 @@ function createServerContext(appConfig, runtimeEnvironment, globalData) {
     globalData,
     runtimeEnvironment
   }, appConfig);
+  const watcherFactory = new import_fs_watch.WatcherFactoryImpl();
   return {
     compiler,
     appObserver,
@@ -70,6 +72,7 @@ function createServerContext(appConfig, runtimeEnvironment, globalData) {
     assetRegistry,
     viewRegistry,
     appConfig,
-    runtimeEnvironment
+    runtimeEnvironment,
+    watcherFactory
   };
 }

package/build/cjs/index.cjs

@@ -33,12 +33,10 @@ var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_server = __toModule(require("@lwrjs/server"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_config = __toModule(require("@lwrjs/config"));
-var import_services = __toModule(require("./context/services.cjs"));
-var import_configurations = __toModule(require("./context/configurations.cjs"));
-var import_provider = __toModule(require("./context/provider.cjs"));
-var import_server2 = __toModule(require("./context/server.cjs"));
 var import_static_generation = __toModule(require("./tools/static-generation.cjs"));
 var import_server_warmup = __toModule(require("./tools/server-warmup.cjs"));
+var import_server2 = __toModule(require("./context/server.cjs"));
+var import_provider = __toModule(require("./context/provider.cjs"));
 var import_locale_middleware = __toModule(require("./middleware/locale-middleware.cjs"));
 var import_module_middleware = __toModule(require("./middleware/module-middleware.cjs"));
 var import_bundle_middleware = __toModule(require("./middleware/bundle-middleware.cjs"));
@@ -48,7 +46,7 @@ var import_view_middleware = __toModule(require("./middleware/view-middleware.cj
 var import_resource_middleware = __toModule(require("./middleware/resource-middleware.cjs"));
 var import_hmr_middleware = __toModule(require("./middleware/hmr-middleware.cjs"));
 var import_server_build = __toModule(require("./tools/server-build.cjs"));
-function initMiddleware(app, server, serverContext) {
+function initMiddleware(app, server, serverContext, routes, errorRoutes) {
   app.useCompression();
   (0, import_locale_middleware.localeMiddleware)(app, serverContext);
   (0, import_module_middleware.moduleMiddleware)(app, serverContext);
@@ -56,28 +54,30 @@ function initMiddleware(app, server, serverContext) {
   (0, import_mapping_middleware.mappingMiddleware)(app, serverContext);
   (0, import_asset_middleware.assetMiddleware)(app, serverContext);
   (0, import_resource_middleware.resourceMiddleware)(app, serverContext);
-  (0, import_view_middleware.viewMiddleware)(app, serverContext);
+  (0, import_view_middleware.viewMiddleware)(app, serverContext, routes, errorRoutes);
   app.initRoutes();
   if (serverContext.runtimeEnvironment.hmrEnabled) {
     (0, import_hmr_middleware.hmrMiddleware)(server, serverContext);
   }
 }
-async function initContext(app, server, rawAppConfig) {
-  const {appConfig, runtimeEnvironment, globalData} = await (0, import_configurations.resolveConfigurations)(rawAppConfig);
+function createServices(entries, providerContext) {
+  return entries.map(([ctor, providerConfig = {}]) => new ctor(providerConfig, providerContext));
+}
+async function initContext(appConfig, runtimeEnvironment, globalData, services) {
   const serverContext = (0, import_server2.createServerContext)(appConfig, runtimeEnvironment, globalData);
   const providerContext = (0, import_provider.createProviderContext)(serverContext);
   const {moduleRegistry, resourceRegistry, viewRegistry, assetRegistry} = serverContext;
-  const moduleProviders = await (0, import_services.getServices)(appConfig.moduleProviders, providerContext, appConfig);
+  const moduleProviders = createServices(services.moduleProviders, providerContext);
   moduleRegistry.addModuleProviders(moduleProviders);
-  const resourceProviders = await (0, import_services.getServices)(appConfig.resourceProviders, providerContext, appConfig);
+  const resourceProviders = await createServices(services.resourceProviders, providerContext);
   resourceRegistry.addResourceProviders(resourceProviders);
-  const viewProviders = await (0, import_services.getServices)(appConfig.viewProviders, providerContext, appConfig);
-  const viewTransformers = await (0, import_services.getServices)(appConfig.viewTransformers, providerContext, rawAppConfig);
+  const viewProviders = await createServices(services.viewProviders, providerContext);
+  const viewTransformers = await createServices(services.viewTransformers, providerContext);
   viewRegistry.addViewProviders(viewProviders);
   viewRegistry.addViewTransformers(viewTransformers);
   await viewRegistry.initializeViewProviders();
-  const assetProviders = await (0, import_services.getServices)(appConfig.assetProviders, providerContext, appConfig);
-  const assetTransformers = await (0, import_services.getServices)(appConfig.assetTransformers, void 0, appConfig);
+  const assetProviders = await createServices(services.assetProviders, providerContext);
+  const assetTransformers = await createServices(services.assetTransformers, providerContext);
   assetRegistry.addAssetProviders(assetProviders);
   assetRegistry.addAssetTransformers(assetTransformers);
   return serverContext;
@@ -97,15 +97,20 @@ var LwrApp = class {
     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;
+    }
+    this.initialized = true;
+    try {
+      const {appConfig, runtimeEnvironment, globalData} = await (0, import_config.loadConfig)(this.config);
+      const services = await (0, import_config.loadServices)(appConfig);
+      const {routes, errorRoutes} = await (0, import_config.loadRoutes)(appConfig);
+      const context = await initContext(appConfig, runtimeEnvironment, globalData, services);
+      initMiddleware(this.app, this.server, context, routes, errorRoutes);
+      this.config = appConfig;
+    } catch (e) {
+      this.initialized = false;
+      throw e;
     }
   }
   async listen(callback) {

package/build/cjs/middleware/view-middleware.cjs

@@ -37,9 +37,8 @@ var 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((route2) => route2.status === 500);
+function createViewMiddleware(route, errorRoutes, context, viewHandler) {
+  const errorRoute = errorRoutes.find((route2) => route2.status === 500);
   return async (req, res) => {
     if (!req.validateEnvironmentRequest(context.appConfig)) {
       res.status(400);
@@ -91,9 +90,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;
@@ -126,20 +123,19 @@ 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(import_diagnostics.descriptions.UNRESOLVABLE.VIEW(req.originalUrl).message);
   };
 }
-function viewMiddleware(app, context) {
+function viewMiddleware(app, context, routes, errorRoutes) {
   const {appConfig, viewRegistry, moduleRegistry} = context;
   const viewHandler = new import_view_registry.LwrViewHandler({viewRegistry, moduleRegistry}, appConfig);
-  for (const route of appConfig.routes) {
+  for (const route of routes) {
     const paths = [route.path];
     const subRoutes = route.subRoutes && (0, import_router.getClientRoutes)(route.subRoutes);
     if (subRoutes) {
@@ -147,8 +143,8 @@ 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, (0, import_error_handling.handleErrors)(createViewMiddleware(route, context, viewHandler)));
+    app.get(paths, (0, import_error_handling.handleErrors)(createViewMiddleware(route, errorRoutes, context, viewHandler)));
   }
-  app.get((0, import_shared_utils.getClientBootstrapConfigurationRoutes)(), (0, import_error_handling.handleErrors)(createConfigMiddleware(context, viewHandler)));
-  app.get("/" + app.getRegexWildcard(), (0, import_error_handling.handleErrors)(createNotFoundMiddleware(context, viewHandler)));
+  app.get((0, import_shared_utils.getClientBootstrapConfigurationRoutes)(), (0, import_error_handling.handleErrors)(createConfigMiddleware(routes, context, viewHandler)));
+  app.get("/" + app.getRegexWildcard(), (0, import_error_handling.handleErrors)(createNotFoundMiddleware(errorRoutes, context, viewHandler)));
 }

package/build/cjs/tools/plugins/build-server-plugin.cjs

@@ -0,0 +1,137 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/core/src/tools/plugins/build-server-plugin.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => buildLwrServer
+});
+var import_path = __toModule(require("path"));
+var import_config = __toModule(require("@lwrjs/config"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var 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 '${(0, import_shared_utils.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 '${(0, import_shared_utils.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, config2 = {}]) => `[${ctor}, ${JSON.stringify(config2)}]`)}]`;
+  }).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(",")}]`;
+}
+function buildLwrServer(config) {
+  return {
+    name: "lwr-server-build",
+    setup(build) {
+      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 (0, import_config.loadConfig)(config, {
+          skipDirNormalization: true
+        });
+        const remoteAppConfig = {
+          ...appConfig,
+          ignoreLwrConfigFile: true,
+          rootDir: void 0,
+          port: void 0
+        };
+        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: import_path.default.dirname(args.path)
+        };
+      });
+    }
+  };
+}

package/build/cjs/{context/services.cjs → tools/plugins/generate-entry-plugin.cjs}

@@ -21,30 +21,35 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/core/src/context/services.ts
+// packages/@lwrjs/core/src/tools/plugins/generate-entry-plugin.ts
 __markAsModule(exports);
 __export(exports, {
-  getServices: () => getServices
+  default: () => generateLwrEntry
 });
 var import_path = __toModule(require("path"));
-var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-async function getServiceModule(path, {cacheDir, rootDir}) {
-  try {
-    if (path.endsWith(".ts")) {
-      const fullPath = (0, import_shared_utils.resolveFileExtension)(path);
-      path = await (0, import_shared_utils.transpileTs)(fullPath, {rootDir, cacheDir: import_path.default.join(cacheDir, "services")});
+function generateLwrEntry() {
+  return {
+    name: "lwr-entry",
+    setup(build) {
+      build.onResolve({filter: /.*\/lwr.entry.js$/}, ({kind, path: path2}) => {
+        if (kind === "entry-point") {
+          return {
+            path: path2,
+            namespace: "lwr-entry"
+          };
+        }
+      });
+      build.onLoad({filter: /.*/, namespace: "lwr-entry"}, (args) => ({
+        contents: [
+          `/* This module is generated */`,
+          `import { createHandler } from '@lwrjs/lambda';`,
+          `import * as build from './lwr.build.js';`,
+          `const handler = createHandler(build);`,
+          `export { handler as get };`
+        ].join("\n"),
+        loader: "ts",
+        resolveDir: import_path.default.dirname(args.path)
+      }));
     }
-    const moduleEntry = await Promise.resolve().then(() => __toModule(require(path)));
-    return moduleEntry.default || moduleEntry;
-  } catch (err) {
-    console.log(err);
-    throw new Error(`Unable to get Service: ${path}`);
-  }
-}
-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);
-  }));
+  };
 }

package/build/cjs/tools/server-build.cjs

@@ -29,126 +29,17 @@ __export(exports, {
 var import_path = __toModule(require("path"));
 var import_fs_extra = __toModule(require("fs-extra"));
 var import_esbuild = __toModule(require("esbuild"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_config = __toModule(require("@lwrjs/config"));
-var import_configurations = __toModule(require("../context/configurations.cjs"));
-var import_provider = __toModule(require("../context/provider.cjs"));
-var import_server = __toModule(require("../context/server.cjs"));
-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 !== void 0;
-}
-function generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata) {
-  const {
-    imports,
-    moduleProviders,
-    resourceProviders,
-    viewProviders,
-    viewTransformers,
-    assetProviders,
-    assetTransformers
-  } = metadata;
-  const config = {
-    ...appConfig,
-    rootDir: void 0,
-    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';`,
-    ...imports,
-    import_server.createServerContext.toString(),
-    import_provider.createProviderContext.toString(),
-    generateServices.toString(),
-    isRemote.toString(),
-    `const config = ${JSON.stringify(config, null, 4)}`,
-    `const runtimeEnvironment = ${JSON.stringify(runtimeEnvironment, null, 4)}`,
-    `const globalData = ${JSON.stringify(globalData, null, 4)}`,
-    `isRemote() && process.chdir(__dirname);`,
-    `isRemote() && (config.rootDir = __dirname);`,
-    `isRemote() && (config.cacheDir = '/tmp/__lwr_cache__');`,
-    `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) {
-  if (target !== "lambda") {
-    throw `Unsupported server build target: ${target}`;
-  }
-  return [
-    `/* This module is generated */`,
-    `import { createHandler } from '@lwrjs/lambda';`,
-    `import build from './lwr.build.js';`,
-    `const handler = createHandler(build);`,
-    `export { handler as get };`
-  ].join("\n");
-}
-async function bundleServer(entryPoint, outputPath) {
+var import_generate_entry_plugin = __toModule(require("./plugins/generate-entry-plugin.cjs"));
+var import_build_server_plugin = __toModule(require("./plugins/build-server-plugin.cjs"));
+async function build(outputDir, config) {
   await import_esbuild.default.build({
-    entryPoints: [entryPoint],
+    entryPoints: ["./lwr.entry.js"],
     bundle: true,
     sourcemap: true,
+    format: "cjs",
+    platform: "node",
     logLevel: "silent",
     external: [
       "node:*",
@@ -160,23 +51,18 @@ async function bundleServer(entryPoint, outputPath) {
       "node-fetch",
       "rollup",
       "rollup-plugin-node-polyfills",
-      "@lwrjs/config",
       "@lwrjs/loader"
     ],
-    format: "cjs",
-    platform: "node",
-    outfile: outputPath
+    banner: {
+      js: `globalThis.LWR_VERSION='${import_config.LWR_VERSION};'`
+    },
+    plugins: [(0, import_generate_entry_plugin.default)(), (0, import_build_server_plugin.default)(config)],
+    outfile: import_path.default.join(outputDir, "ssr.js")
   });
 }
 async function buildServer(configArg, options) {
-  const config = (0, import_config.normalizeConfig)(configArg, {skipDirNormalization: true, skipCacheDirCreation: true});
-  const {appConfig, runtimeEnvironment, globalData} = await (0, import_configurations.resolveConfigurations)(config);
-  const metadata = getBuildMetadata(appConfig);
-  const serverContext = generateServerContextModule(appConfig, runtimeEnvironment, globalData, metadata);
-  const outputDir = import_path.default.join(appConfig.rootDir, options?.outputDir || "/build");
-  const serverSource = generateServerSource(options?.target || "lambda");
+  const outputDir = import_path.default.join(configArg?.rootDir || process.cwd(), options?.outputDir || "/build");
   await import_fs_extra.default.ensureDir(outputDir);
-  await import_fs_extra.default.writeFile(import_path.default.join(outputDir, "lwr.build.js"), serverContext);
-  await import_fs_extra.default.writeFile(import_path.default.join(outputDir, "entry.js"), serverSource);
-  await bundleServer(import_path.default.join(outputDir, "entry.js"), import_path.default.join(outputDir, "ssr.js"));
+  await build(outputDir, configArg);
+  import_shared_utils.logger.info("Successfully built the server");
 }

package/build/cjs/tools/server-warmup.cjs

@@ -36,17 +36,10 @@ async function warmupServer(config, internalRequestKey) {
     import_shared_utils.logger.setOptions({dedupe: new Set([import_shared_utils.WARN])});
   }
   import_shared_utils.logger.info("[Server Warmup] starting");
-  const {routes, staticSiteGenerator, port, apiVersion, basePath, lwrVersion, serverMode} = config;
+  const {routes, staticSiteGenerator, port, basePath} = config;
   staticSiteGenerator.outputDir = import_dir.skipDirCreation;
   const urlRewriteMap = new Map();
-  const runtimeEnvironment = {
-    ...(0, import_config.explodeMode)(serverMode),
-    apiVersion,
-    basePath,
-    lwrVersion,
-    debug: false,
-    serverMode
-  };
+  const runtimeEnvironment = (0, import_config.getRuntimeEnvironment)(config);
   await new import_static_generation.default().generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, new import_network_dispatcher.default(port, internalRequestKey), staticSiteGenerator.outputDir, urlRewriteMap);
   import_shared_utils.logger.info("[Server Warmup] complete");
 }

package/build/cjs/tools/static-generation.cjs

@@ -46,18 +46,15 @@ var SiteGenerator = class {
       staticSiteGenerator.outputDir = "__generated_site__";
     }
     const outputDir = (0, import_path.join)(rootDir, staticSiteGenerator.outputDir);
-    import_shared_utils.logger.info(`Clear Output Location: ${outputDir}`);
-    import_fs_extra.default.rmSync(outputDir, {recursive: true, force: true});
+    if (!staticSiteGenerator.skipCleanOutputDir) {
+      import_shared_utils.logger.info(`Clearing output directory: ${outputDir}`);
+      import_fs_extra.default.rmSync(outputDir, {recursive: true, force: true});
+    } else {
+      import_shared_utils.logger.info(`Reusing existing output directory: ${outputDir}`);
+    }
     const urlRewriteMap = new Map();
-    const {apiVersion, basePath, lwrVersion, serverMode} = config;
-    const runtimeEnvironment = {
-      ...(0, import_config.explodeMode)(serverMode),
-      apiVersion,
-      basePath,
-      lwrVersion,
-      debug: false,
-      serverMode
-    };
+    const {basePath} = config;
+    const runtimeEnvironment = (0, import_config.getRuntimeEnvironment)(config);
     await this.generateRoutes(runtimeEnvironment, staticSiteGenerator, routes, basePath, dispatcher, outputDir, urlRewriteMap);
     this.writeNetlifyRedirectConfig(outputDir, urlRewriteMap);
     this.copyAssets(assets, outputDir, basePath);

package/build/es/context/provider.js

@@ -33,6 +33,7 @@ export function createProviderContext(serverContext) {
             environment,
         }),
         runtimeEnvironment: deepFreeze(serverContext.runtimeEnvironment),
+        watcherFactory: serverContext.watcherFactory,
     };
 }
 //# sourceMappingURL=provider.js.map

package/build/es/context/server.js

@@ -5,6 +5,8 @@ import { LwrModuleRegistry } from '@lwrjs/module-registry';
 import { LwrResourceRegistry } from '@lwrjs/resource-registry';
 import { LwrApplicationObserver } from '@lwrjs/shared-utils';
 import { LwrViewRegistry } from '@lwrjs/view-registry';
+// dependency chokidar in this package.json is to statisfy the optional dependency in shared-utils for fs-watch.
+import { WatcherFactoryImpl } from '@lwrjs/shared-utils/fs-watch';
 export function createServerContext(appConfig, runtimeEnvironment, globalData) {
     const appObserver = new LwrApplicationObserver();
     const appEmitter = appObserver.createLwrEmitter();
@@ -32,6 +34,7 @@ export function createServerContext(appConfig, runtimeEnvironment, globalData) {
         globalData,
         runtimeEnvironment,
     }, appConfig);
+    const watcherFactory = new WatcherFactoryImpl();
     return {
         compiler,
         appObserver,
@@ -43,6 +46,7 @@ export function createServerContext(appConfig, runtimeEnvironment, globalData) {
         viewRegistry,
         appConfig,
         runtimeEnvironment,
+        watcherFactory,
     };
 }
 //# sourceMappingURL=server.js.map