@backstage/backend-app-api 0.3.2-next.1 → 0.4.0

package/dist/index.cjs.js

@@ -295,7 +295,7 @@ function readHttpsOptions(config) {
   }
   return {
     certificate: {
-      type: "plain",
+      type: "pem",
       cert: cc.getString("certificate.cert"),
       key: cc.getString("certificate.key")
     }
@@ -898,16 +898,14 @@ var __privateSet$4 = (obj, member, value, setter) => {
   return value;
 };
 var _isCalled, _shutdownTasks;
-const CALLBACKS = ["SIGTERM", "SIGINT", "beforeExit"];
 class BackendLifecycleImpl {
   constructor(logger) {
     this.logger = logger;
     __privateAdd$4(this, _isCalled, false);
     __privateAdd$4(this, _shutdownTasks, []);
-    CALLBACKS.map((signal) => process.on(signal, () => this.shutdown()));
   }
-  addShutdownHook(options) {
-    __privateGet$4(this, _shutdownTasks).push(options);
+  addShutdownHook(hook, options) {
+    __privateGet$4(this, _shutdownTasks).push({ hook, options });
   }
   async shutdown() {
     if (__privateGet$4(this, _isCalled)) {
@@ -916,10 +914,11 @@ class BackendLifecycleImpl {
     __privateSet$4(this, _isCalled, true);
     this.logger.info(`Running ${__privateGet$4(this, _shutdownTasks).length} shutdown tasks...`);
     await Promise.all(
-      __privateGet$4(this, _shutdownTasks).map(async (hook) => {
-        const { logger = this.logger } = hook;
+      __privateGet$4(this, _shutdownTasks).map(async ({ hook, options }) => {
+        var _a;
+        const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
         try {
-          await hook.fn();
+          await hook();
           logger.info(`Shutdown hook succeeded`);
         } catch (error) {
           logger.error(`Shutdown hook failed, ${error}`);
@@ -930,7 +929,7 @@ class BackendLifecycleImpl {
 }
 _isCalled = new WeakMap();
 _shutdownTasks = new WeakMap();
-const rootLifecycleFactory = backendPluginApi.createServiceFactory({
+const rootLifecycleServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.rootLifecycle,
   deps: {
     logger: backendPluginApi.coreServices.rootLogger
@@ -962,78 +961,63 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$3(obj, member, "access private method");
   return method;
 };
-var _started, _features, _registerInits, _extensionPoints, _serviceHolder, _getInitDeps, getInitDeps_fn, _resolveInitOrder, resolveInitOrder_fn;
+var _startPromise, _features, _registerInits, _extensionPoints, _serviceHolder, _getInitDeps, getInitDeps_fn, _doStart, doStart_fn, _resolveInitOrder, resolveInitOrder_fn;
 class BackendInitializer {
   constructor(serviceHolder) {
     __privateAdd$3(this, _getInitDeps);
+    __privateAdd$3(this, _doStart);
     __privateAdd$3(this, _resolveInitOrder);
-    __privateAdd$3(this, _started, false);
-    __privateAdd$3(this, _features, /* @__PURE__ */ new Map());
+    __privateAdd$3(this, _startPromise, void 0);
+    __privateAdd$3(this, _features, new Array());
     __privateAdd$3(this, _registerInits, new Array());
     __privateAdd$3(this, _extensionPoints, /* @__PURE__ */ new Map());
     __privateAdd$3(this, _serviceHolder, void 0);
     __privateSet$3(this, _serviceHolder, serviceHolder);
   }
-  add(feature, options) {
-    if (__privateGet$3(this, _started)) {
+  add(feature) {
+    if (__privateGet$3(this, _startPromise)) {
       throw new Error("feature can not be added after the backend has started");
     }
-    __privateGet$3(this, _features).set(feature, options);
+    if (feature.$$type !== "@backstage/BackendFeature") {
+      throw new Error(
+        `Failed to add feature, invalid type '${feature.$$type}'`
+      );
+    }
+    const internalFeature = feature;
+    if (internalFeature.version !== "v1") {
+      throw new Error(
+        `Failed to add feature, invalid version '${internalFeature.version}'`
+      );
+    }
+    __privateGet$3(this, _features).push(internalFeature);
   }
   async start() {
-    if (__privateGet$3(this, _started)) {
+    if (__privateGet$3(this, _startPromise)) {
       throw new Error("Backend has already started");
     }
-    __privateSet$3(this, _started, true);
-    for (const ref of __privateGet$3(this, _serviceHolder).getServiceRefs()) {
-      if (ref.scope === "root") {
-        await __privateGet$3(this, _serviceHolder).get(ref, "root");
-      }
-    }
-    for (const [feature] of __privateGet$3(this, _features)) {
-      const provides = /* @__PURE__ */ new Set();
-      let registerInit = void 0;
-      feature.register({
-        registerExtensionPoint: (extensionPointRef, impl) => {
-          if (registerInit) {
-            throw new Error("registerExtensionPoint called after registerInit");
-          }
-          if (__privateGet$3(this, _extensionPoints).has(extensionPointRef)) {
-            throw new Error(`API ${extensionPointRef.id} already registered`);
-          }
-          __privateGet$3(this, _extensionPoints).set(extensionPointRef, impl);
-          provides.add(extensionPointRef);
-        },
-        registerInit: (registerOptions) => {
-          if (registerInit) {
-            throw new Error("registerInit must only be called once");
-          }
-          registerInit = {
-            id: feature.id,
-            provides,
-            consumes: new Set(Object.values(registerOptions.deps)),
-            deps: registerOptions.deps,
-            init: registerOptions.init
-          };
-        }
-      });
-      if (!registerInit) {
-        throw new Error(
-          `registerInit was not called by register in ${feature.id}`
-        );
+    const exitHandler = async () => {
+      process.removeListener("SIGTERM", exitHandler);
+      process.removeListener("SIGINT", exitHandler);
+      process.removeListener("beforeExit", exitHandler);
+      try {
+        await this.stop();
+        process.exit(0);
+      } catch (error) {
+        console.error(error);
+        process.exit(1);
       }
-      __privateGet$3(this, _registerInits).push(registerInit);
-    }
-    const orderedRegisterResults = __privateMethod$2(this, _resolveInitOrder, resolveInitOrder_fn).call(this, __privateGet$3(this, _registerInits));
-    for (const registerInit of orderedRegisterResults) {
-      const deps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, registerInit.deps, registerInit.id);
-      await registerInit.init(deps);
-    }
+    };
+    process.addListener("SIGTERM", exitHandler);
+    process.addListener("SIGINT", exitHandler);
+    process.addListener("beforeExit", exitHandler);
+    __privateSet$3(this, _startPromise, __privateMethod$2(this, _doStart, doStart_fn).call(this));
+    await __privateGet$3(this, _startPromise);
   }
   async stop() {
-    if (!__privateGet$3(this, _started)) {
+    if (!__privateGet$3(this, _startPromise)) {
       return;
     }
+    await __privateGet$3(this, _startPromise);
     const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
       backendPluginApi.coreServices.rootLifecycle,
       "root"
@@ -1045,7 +1029,7 @@ class BackendInitializer {
     }
   }
 }
-_started = new WeakMap();
+_startPromise = new WeakMap();
 _features = new WeakMap();
 _registerInits = new WeakMap();
 _extensionPoints = new WeakMap();
@@ -1080,6 +1064,41 @@ getInitDeps_fn = async function(deps, pluginId) {
   }
   return Object.fromEntries(result);
 };
+_doStart = new WeakSet();
+doStart_fn = async function() {
+  for (const ref of __privateGet$3(this, _serviceHolder).getServiceRefs()) {
+    if (ref.scope === "root") {
+      await __privateGet$3(this, _serviceHolder).get(ref, "root");
+    }
+  }
+  for (const feature of __privateGet$3(this, _features)) {
+    for (const r of feature.getRegistrations()) {
+      const provides = /* @__PURE__ */ new Set();
+      if (r.type === "plugin") {
+        for (const [extRef, extImpl] of r.extensionPoints) {
+          if (__privateGet$3(this, _extensionPoints).has(extRef)) {
+            throw new Error(
+              `ExtensionPoint with ID '${extRef.id}' is already registered`
+            );
+          }
+          __privateGet$3(this, _extensionPoints).set(extRef, extImpl);
+          provides.add(extRef);
+        }
+      }
+      __privateGet$3(this, _registerInits).push({
+        id: r.type === "plugin" ? r.pluginId : `${r.pluginId}.${r.moduleId}`,
+        provides,
+        consumes: new Set(Object.values(r.init.deps)),
+        init: r.init
+      });
+    }
+  }
+  const orderedRegisterResults = __privateMethod$2(this, _resolveInitOrder, resolveInitOrder_fn).call(this, __privateGet$3(this, _registerInits));
+  for (const registerInit of orderedRegisterResults) {
+    const deps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, registerInit.init.deps, registerInit.id);
+    await registerInit.init.func(deps);
+  }
+};
 _resolveInitOrder = new WeakSet();
 resolveInitOrder_fn = function(registerInits) {
   let registerInitsToOrder = registerInits.slice();
@@ -1128,6 +1147,23 @@ var __privateMethod$1 = (obj, member, method) => {
   return method;
 };
 var _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn;
+function toInternalServiceFactory(factory) {
+  const f = factory;
+  if (f.$$type !== "@backstage/ServiceFactory") {
+    throw new Error(`Invalid service factory, bad type '${f.$$type}'`);
+  }
+  if (f.version !== "v1") {
+    throw new Error(`Invalid service factory, bad version '${f.version}'`);
+  }
+  return f;
+}
+const pluginMetadataServiceFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.pluginMetadata,
+    deps: {},
+    factory: async () => ({ getId: () => options.pluginId })
+  })
+);
 class ServiceRegistry {
   constructor(factories) {
     __privateAdd$2(this, _resolveFactory);
@@ -1136,7 +1172,9 @@ class ServiceRegistry {
     __privateAdd$2(this, _loadedDefaultFactories, void 0);
     __privateAdd$2(this, _implementations, void 0);
     __privateAdd$2(this, _rootServiceImplementations, /* @__PURE__ */ new Map());
-    __privateSet$2(this, _providedFactories, new Map(factories.map((f) => [f.service.id, f])));
+    __privateSet$2(this, _providedFactories, new Map(
+      factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
+    ));
     __privateSet$2(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
     __privateSet$2(this, _implementations, /* @__PURE__ */ new Map());
   }
@@ -1146,7 +1184,7 @@ class ServiceRegistry {
   get(ref, pluginId) {
     var _a;
     return (_a = __privateMethod$1(this, _resolveFactory, resolveFactory_fn).call(this, ref, pluginId)) == null ? void 0 : _a.then((factory) => {
-      if (factory.scope === "root") {
+      if (factory.service.scope === "root") {
         let existing = __privateGet$2(this, _rootServiceImplementations).get(factory);
         if (!existing) {
           __privateMethod$1(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
@@ -1161,7 +1199,7 @@ class ServiceRegistry {
             rootDeps.push(target.then((impl) => [name, impl]));
           }
           existing = Promise.all(rootDeps).then(
-            (entries) => factory.factory(Object.fromEntries(entries))
+            (entries) => factory.factory(Object.fromEntries(entries), void 0)
           );
           __privateGet$2(this, _rootServiceImplementations).set(factory, existing);
         }
@@ -1223,12 +1261,9 @@ _rootServiceImplementations = new WeakMap();
 _resolveFactory = new WeakSet();
 resolveFactory_fn = function(ref, pluginId) {
   if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
-    return Promise.resolve({
-      scope: "plugin",
-      service: backendPluginApi.coreServices.pluginMetadata,
-      deps: {},
-      factory: async () => ({ getId: () => pluginId })
-    });
+    return Promise.resolve(
+      toInternalServiceFactory(pluginMetadataServiceFactory({ pluginId }))
+    );
   }
   let resolvedFactory = __privateGet$2(this, _providedFactories).get(ref.id);
   const { __defaultFactory: defaultFactory } = ref;
@@ -1239,7 +1274,7 @@ resolveFactory_fn = function(ref, pluginId) {
     let loadedFactory = __privateGet$2(this, _loadedDefaultFactories).get(defaultFactory);
     if (!loadedFactory) {
       loadedFactory = Promise.resolve().then(() => defaultFactory(ref)).then(
-        (f) => typeof f === "function" ? f() : f
+        (f) => toInternalServiceFactory(typeof f === "function" ? f() : f)
       );
       __privateGet$2(this, _loadedDefaultFactories).set(defaultFactory, loadedFactory);
     }
@@ -1336,7 +1371,7 @@ function createSpecializedBackend(options) {
   return new BackstageBackend(services);
 }
 
-const cacheFactory = backendPluginApi.createServiceFactory({
+const cacheServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.cache,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1346,25 +1381,28 @@ const cacheFactory = backendPluginApi.createServiceFactory({
     return backendCommon.CacheManager.fromConfig(config);
   },
   async factory({ plugin }, manager) {
-    return manager.forPlugin(plugin.getId());
+    return manager.forPlugin(plugin.getId()).getClient();
   }
 });
 
-const configFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.config,
-  deps: {},
-  async factory({}, options) {
-    const { argv = process.argv, remote } = options != null ? options : {};
-    const { config } = await loadBackendConfig({ argv, remote });
-    return config;
-  }
-});
+const configServiceFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.config,
+    deps: {},
+    async factory({}) {
+      const { argv = process.argv, remote } = options != null ? options : {};
+      const { config } = await loadBackendConfig({ argv, remote });
+      return config;
+    }
+  })
+);
 
-const databaseFactory = backendPluginApi.createServiceFactory({
+const databaseServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.database,
   deps: {
     config: backendPluginApi.coreServices.config,
-    plugin: backendPluginApi.coreServices.pluginMetadata
+    lifecycle: backendPluginApi.coreServices.lifecycle,
+    pluginMetadata: backendPluginApi.coreServices.pluginMetadata
   },
   async createRootContext({ config: config$1 }) {
     return config$1.getOptional("backend.database") ? backendCommon.DatabaseManager.fromConfig(config$1) : backendCommon.DatabaseManager.fromConfig(
@@ -1375,12 +1413,15 @@ const databaseFactory = backendPluginApi.createServiceFactory({
       })
     );
   },
-  async factory({ plugin }, databaseManager) {
-    return databaseManager.forPlugin(plugin.getId());
+  async factory({ pluginMetadata, lifecycle }, databaseManager) {
+    return databaseManager.forPlugin(pluginMetadata.getId(), {
+      pluginMetadata,
+      lifecycle
+    });
   }
 });
 
-const discoveryFactory = backendPluginApi.createServiceFactory({
+const discoveryServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.discovery,
   deps: {
     config: backendPluginApi.coreServices.config
@@ -1390,7 +1431,7 @@ const discoveryFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const httpRouterFactory = backendPluginApi.createServiceFactory(
+const httpRouterServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.httpRouter,
     deps: {
@@ -1410,7 +1451,7 @@ const httpRouterFactory = backendPluginApi.createServiceFactory(
   })
 );
 
-const identityFactory = backendPluginApi.createServiceFactory(
+const identityServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.identity,
     deps: {
@@ -1422,7 +1463,7 @@ const identityFactory = backendPluginApi.createServiceFactory(
   })
 );
 
-const lifecycleFactory = backendPluginApi.createServiceFactory({
+const lifecycleServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.lifecycle,
   deps: {
     logger: backendPluginApi.coreServices.logger,
@@ -1432,18 +1473,17 @@ const lifecycleFactory = backendPluginApi.createServiceFactory({
   async factory({ rootLifecycle, logger, pluginMetadata }) {
     const plugin = pluginMetadata.getId();
     return {
-      addShutdownHook(options) {
+      addShutdownHook(hook, options) {
         var _a, _b;
-        rootLifecycle.addShutdownHook({
-          ...options,
-          logger: (_b = (_a = options.logger) == null ? void 0 : _a.child({ plugin })) != null ? _b : logger
+        rootLifecycle.addShutdownHook(hook, {
+          logger: (_b = (_a = options == null ? void 0 : options.logger) == null ? void 0 : _a.child({ plugin })) != null ? _b : logger
         });
       }
     };
   }
 });
 
-const loggerFactory = backendPluginApi.createServiceFactory({
+const loggerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.logger,
   deps: {
     rootLogger: backendPluginApi.coreServices.rootLogger,
@@ -1454,7 +1494,7 @@ const loggerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const permissionsFactory = backendPluginApi.createServiceFactory({
+const permissionsServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.permissions,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1563,11 +1603,8 @@ findConflictingPath_fn = function(newPath) {
   return void 0;
 };
 
-function defaultConfigure({
-  app,
-  routes,
-  middleware
-}) {
+function defaultConfigure(context) {
+  const { app, routes, middleware } = context;
   app.use(middleware.helmet());
   app.use(middleware.cors());
   app.use(middleware.compression());
@@ -1576,46 +1613,41 @@ function defaultConfigure({
   app.use(middleware.notFound());
   app.use(middleware.error());
 }
-const rootHttpRouterFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.rootHttpRouter,
-  deps: {
-    config: backendPluginApi.coreServices.config,
-    rootLogger: backendPluginApi.coreServices.rootLogger,
-    lifecycle: backendPluginApi.coreServices.rootLifecycle
-  },
-  async factory({ config, rootLogger, lifecycle }, {
-    indexPath,
-    configure = defaultConfigure
-  } = {}) {
-    const logger = rootLogger.child({ service: "rootHttpRouter" });
-    const app = express__default["default"]();
-    const router = DefaultRootHttpRouter.create({ indexPath });
-    const middleware = MiddlewareFactory.create({ config, logger });
-    configure({
-      app,
-      routes: router.handler(),
-      middleware,
-      config,
-      logger,
-      lifecycle
-    });
-    const server = await createHttpServer(
-      app,
-      readHttpServerOptions(config.getOptionalConfig("backend")),
-      { logger }
-    );
-    lifecycle.addShutdownHook({
-      async fn() {
-        await server.stop();
-      },
-      logger
-    });
-    await server.start();
-    return router;
-  }
-});
+const rootHttpRouterServiceFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.rootHttpRouter,
+    deps: {
+      config: backendPluginApi.coreServices.config,
+      rootLogger: backendPluginApi.coreServices.rootLogger,
+      lifecycle: backendPluginApi.coreServices.rootLifecycle
+    },
+    async factory({ config, rootLogger, lifecycle }) {
+      const { indexPath, configure = defaultConfigure } = options != null ? options : {};
+      const logger = rootLogger.child({ service: "rootHttpRouter" });
+      const app = express__default["default"]();
+      const router = DefaultRootHttpRouter.create({ indexPath });
+      const middleware = MiddlewareFactory.create({ config, logger });
+      configure({
+        app,
+        routes: router.handler(),
+        middleware,
+        config,
+        logger,
+        lifecycle
+      });
+      const server = await createHttpServer(
+        app,
+        readHttpServerOptions(config.getOptionalConfig("backend")),
+        { logger }
+      );
+      lifecycle.addShutdownHook(() => server.stop());
+      await server.start();
+      return router;
+    }
+  })
+);
 
-const rootLoggerFactory = backendPluginApi.createServiceFactory({
+const rootLoggerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.rootLogger,
   deps: {
     config: backendPluginApi.coreServices.config
@@ -1637,7 +1669,7 @@ const rootLoggerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const schedulerFactory = backendPluginApi.createServiceFactory({
+const schedulerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.scheduler,
   deps: {
     plugin: backendPluginApi.coreServices.pluginMetadata,
@@ -1653,7 +1685,7 @@ const schedulerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const tokenManagerFactory = backendPluginApi.createServiceFactory({
+const tokenManagerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.tokenManager,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1669,7 +1701,7 @@ const tokenManagerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const urlReaderFactory = backendPluginApi.createServiceFactory({
+const urlReaderServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.urlReader,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1686,26 +1718,26 @@ const urlReaderFactory = backendPluginApi.createServiceFactory({
 exports.DefaultRootHttpRouter = DefaultRootHttpRouter;
 exports.MiddlewareFactory = MiddlewareFactory;
 exports.WinstonLogger = WinstonLogger;
-exports.cacheFactory = cacheFactory;
-exports.configFactory = configFactory;
+exports.cacheServiceFactory = cacheServiceFactory;
+exports.configServiceFactory = configServiceFactory;
 exports.createConfigSecretEnumerator = createConfigSecretEnumerator;
 exports.createHttpServer = createHttpServer;
 exports.createSpecializedBackend = createSpecializedBackend;
-exports.databaseFactory = databaseFactory;
-exports.discoveryFactory = discoveryFactory;
-exports.httpRouterFactory = httpRouterFactory;
-exports.identityFactory = identityFactory;
-exports.lifecycleFactory = lifecycleFactory;
+exports.databaseServiceFactory = databaseServiceFactory;
+exports.discoveryServiceFactory = discoveryServiceFactory;
+exports.httpRouterServiceFactory = httpRouterServiceFactory;
+exports.identityServiceFactory = identityServiceFactory;
+exports.lifecycleServiceFactory = lifecycleServiceFactory;
 exports.loadBackendConfig = loadBackendConfig;
-exports.loggerFactory = loggerFactory;
-exports.permissionsFactory = permissionsFactory;
+exports.loggerServiceFactory = loggerServiceFactory;
+exports.permissionsServiceFactory = permissionsServiceFactory;
 exports.readCorsOptions = readCorsOptions;
 exports.readHelmetOptions = readHelmetOptions;
 exports.readHttpServerOptions = readHttpServerOptions;
-exports.rootHttpRouterFactory = rootHttpRouterFactory;
-exports.rootLifecycleFactory = rootLifecycleFactory;
-exports.rootLoggerFactory = rootLoggerFactory;
-exports.schedulerFactory = schedulerFactory;
-exports.tokenManagerFactory = tokenManagerFactory;
-exports.urlReaderFactory = urlReaderFactory;
+exports.rootHttpRouterServiceFactory = rootHttpRouterServiceFactory;
+exports.rootLifecycleServiceFactory = rootLifecycleServiceFactory;
+exports.rootLoggerServiceFactory = rootLoggerServiceFactory;
+exports.schedulerServiceFactory = schedulerServiceFactory;
+exports.tokenManagerServiceFactory = tokenManagerServiceFactory;
+exports.urlReaderServiceFactory = urlReaderServiceFactory;
 //# sourceMappingURL=index.cjs.js.map