@backstage/backend-app-api 0.4.4-next.0 → 0.4.4-next.2

package/dist/index.cjs.js

@@ -22,6 +22,7 @@ var errors = require('@backstage/errors');
 var winston = require('winston');
 var backendPluginApi = require('@backstage/backend-plugin-api');
 var backendCommon = require('@backstage/backend-common');
+var PromiseRouter = require('express-promise-router');
 var pluginAuthNode = require('@backstage/plugin-auth-node');
 var pluginPermissionNode = require('@backstage/plugin-permission-node');
 var express = require('express');
@@ -58,6 +59,7 @@ var cors__default = /*#__PURE__*/_interopDefaultLegacy(cors);
 var helmet__default = /*#__PURE__*/_interopDefaultLegacy(helmet);
 var morgan__default = /*#__PURE__*/_interopDefaultLegacy(morgan);
 var compression__default = /*#__PURE__*/_interopDefaultLegacy(compression);
+var PromiseRouter__default = /*#__PURE__*/_interopDefaultLegacy(PromiseRouter);
 var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
 var trimEnd__default = /*#__PURE__*/_interopDefaultLegacy(trimEnd);
 
@@ -575,31 +577,31 @@ function createCorsOriginMatcher(allowedOriginPatterns) {
   };
 }
 
-var __accessCheck$6 = (obj, member, msg) => {
+var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$6 = (obj, member, getter) => {
-  __accessCheck$6(obj, member, "read from private field");
+var __privateGet$7 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$6 = (obj, member, value) => {
+var __privateAdd$7 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$6 = (obj, member, value, setter) => {
-  __accessCheck$6(obj, member, "write to private field");
+var __privateSet$7 = (obj, member, value, setter) => {
+  __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _config, _logger;
 const _MiddlewareFactory = class {
   constructor(options) {
-    __privateAdd$6(this, _config, void 0);
-    __privateAdd$6(this, _logger, void 0);
-    __privateSet$6(this, _config, options.config);
-    __privateSet$6(this, _logger, options.logger);
+    __privateAdd$7(this, _config, void 0);
+    __privateAdd$7(this, _logger, void 0);
+    __privateSet$7(this, _config, options.config);
+    __privateSet$7(this, _logger, options.logger);
   }
   /**
    * Creates a new {@link MiddlewareFactory}.
@@ -645,7 +647,7 @@ const _MiddlewareFactory = class {
    * @returns An Express request handler
    */
   logging() {
-    const logger = __privateGet$6(this, _logger).child({
+    const logger = __privateGet$7(this, _logger).child({
       type: "incomingRequest"
     });
     return morgan__default["default"]("combined", {
@@ -669,7 +671,7 @@ const _MiddlewareFactory = class {
    * @returns An Express request handler
    */
   helmet() {
-    return helmet__default["default"](readHelmetOptions(__privateGet$6(this, _config).getOptionalConfig("backend")));
+    return helmet__default["default"](readHelmetOptions(__privateGet$7(this, _config).getOptionalConfig("backend")));
   }
   /**
    * Returns a middleware that implements the cors library.
@@ -684,7 +686,7 @@ const _MiddlewareFactory = class {
    * @returns An Express request handler
    */
   cors() {
-    return cors__default["default"](readCorsOptions(__privateGet$6(this, _config).getOptionalConfig("backend")));
+    return cors__default["default"](readCorsOptions(__privateGet$7(this, _config).getOptionalConfig("backend")));
   }
   /**
    * Express middleware to handle errors during request processing.
@@ -709,7 +711,7 @@ const _MiddlewareFactory = class {
   error(options = {}) {
     var _a;
     const showStackTraces = (_a = options.showStackTraces) != null ? _a : process.env.NODE_ENV === "development";
-    const logger = __privateGet$6(this, _logger).child({
+    const logger = __privateGet$7(this, _logger).child({
       type: "errorHandler"
     });
     return (error, req, res, next) => {
@@ -757,6 +759,8 @@ function getStatusCode(error) {
       return 409;
     case errors.NotImplementedError.name:
       return 501;
+    case errors.ServiceUnavailableError.name:
+      return 503;
   }
   return 500;
 }
@@ -765,31 +769,31 @@ const escapeRegExp = (text) => {
   return text.replace(/[.*+?^${}(\)|[\]\\]/g, "\\$&");
 };
 
-var __accessCheck$5 = (obj, member, msg) => {
+var __accessCheck$6 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$5 = (obj, member, value) => {
+var __privateAdd$6 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$5 = (obj, member, value, setter) => {
-  __accessCheck$5(obj, member, "write to private field");
+var __privateSet$6 = (obj, member, value, setter) => {
+  __accessCheck$6(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _winston, _addRedactions;
 const _WinstonLogger = class {
   constructor(winston, addRedactions) {
-    __privateAdd$5(this, _winston, void 0);
-    __privateAdd$5(this, _addRedactions, void 0);
-    __privateSet$5(this, _winston, winston);
-    __privateSet$5(this, _addRedactions, addRedactions);
+    __privateAdd$6(this, _winston, void 0);
+    __privateAdd$6(this, _addRedactions, void 0);
+    __privateSet$6(this, _winston, winston);
+    __privateSet$6(this, _addRedactions, addRedactions);
   }
   /**
    * Creates a {@link WinstonLogger} instance.
@@ -866,70 +870,102 @@ const _WinstonLogger = class {
     );
   }
   error(message, meta) {
-    __privateGet$5(this, _winston).error(message, meta);
+    __privateGet$6(this, _winston).error(message, meta);
   }
   warn(message, meta) {
-    __privateGet$5(this, _winston).warn(message, meta);
+    __privateGet$6(this, _winston).warn(message, meta);
   }
   info(message, meta) {
-    __privateGet$5(this, _winston).info(message, meta);
+    __privateGet$6(this, _winston).info(message, meta);
   }
   debug(message, meta) {
-    __privateGet$5(this, _winston).debug(message, meta);
+    __privateGet$6(this, _winston).debug(message, meta);
   }
   child(meta) {
-    return new _WinstonLogger(__privateGet$5(this, _winston).child(meta));
+    return new _WinstonLogger(__privateGet$6(this, _winston).child(meta));
   }
   addRedactions(redactions) {
     var _a;
-    (_a = __privateGet$5(this, _addRedactions)) == null ? void 0 : _a.call(this, redactions);
+    (_a = __privateGet$6(this, _addRedactions)) == null ? void 0 : _a.call(this, redactions);
   }
 };
 let WinstonLogger = _WinstonLogger;
 _winston = new WeakMap();
 _addRedactions = new WeakMap();
 
-var __accessCheck$4 = (obj, member, msg) => {
+var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$4 = (obj, member, value) => {
+var __privateAdd$5 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$4 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
+var __privateSet$5 = (obj, member, value, setter) => {
+  __accessCheck$5(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _isCalled, _shutdownTasks;
+var _hasStarted$1, _startupTasks$1, _hasShutdown, _shutdownTasks;
 class BackendLifecycleImpl {
   constructor(logger) {
     this.logger = logger;
-    __privateAdd$4(this, _isCalled, false);
-    __privateAdd$4(this, _shutdownTasks, []);
+    __privateAdd$5(this, _hasStarted$1, false);
+    __privateAdd$5(this, _startupTasks$1, []);
+    __privateAdd$5(this, _hasShutdown, false);
+    __privateAdd$5(this, _shutdownTasks, []);
+  }
+  addStartupHook(hook, options) {
+    if (__privateGet$5(this, _hasStarted$1)) {
+      throw new Error("Attempted to add startup hook after startup");
+    }
+    __privateGet$5(this, _startupTasks$1).push({ hook, options });
+  }
+  async startup() {
+    if (__privateGet$5(this, _hasStarted$1)) {
+      return;
+    }
+    __privateSet$5(this, _hasStarted$1, true);
+    this.logger.debug(`Running ${__privateGet$5(this, _startupTasks$1).length} startup tasks...`);
+    await Promise.all(
+      __privateGet$5(this, _startupTasks$1).map(async ({ hook, options }) => {
+        var _a;
+        const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
+        try {
+          await hook();
+          logger.debug(`Startup hook succeeded`);
+        } catch (error) {
+          logger.error(`Startup hook failed, ${error}`);
+        }
+      })
+    );
   }
   addShutdownHook(hook, options) {
-    __privateGet$4(this, _shutdownTasks).push({ hook, options });
+    if (__privateGet$5(this, _hasShutdown)) {
+      throw new Error("Attempted to add shutdown hook after shutdown");
+    }
+    __privateGet$5(this, _shutdownTasks).push({ hook, options });
   }
   async shutdown() {
-    if (__privateGet$4(this, _isCalled)) {
+    if (__privateGet$5(this, _hasShutdown)) {
       return;
     }
-    __privateSet$4(this, _isCalled, true);
-    this.logger.info(`Running ${__privateGet$4(this, _shutdownTasks).length} shutdown tasks...`);
+    __privateSet$5(this, _hasShutdown, true);
+    this.logger.debug(
+      `Running ${__privateGet$5(this, _shutdownTasks).length} shutdown tasks...`
+    );
     await Promise.all(
-      __privateGet$4(this, _shutdownTasks).map(async ({ hook, options }) => {
+      __privateGet$5(this, _shutdownTasks).map(async ({ hook, options }) => {
         var _a;
         const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
         try {
           await hook();
-          logger.info(`Shutdown hook succeeded`);
+          logger.debug(`Shutdown hook succeeded`);
         } catch (error) {
           logger.error(`Shutdown hook failed, ${error}`);
         }
@@ -937,7 +973,9 @@ class BackendLifecycleImpl {
     );
   }
 }
-_isCalled = new WeakMap();
+_hasStarted$1 = new WeakMap();
+_startupTasks$1 = new WeakMap();
+_hasShutdown = new WeakMap();
 _shutdownTasks = new WeakMap();
 const rootLifecycleServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.rootLifecycle,
@@ -949,6 +987,86 @@ const rootLifecycleServiceFactory = backendPluginApi.createServiceFactory({
   }
 });
 
+var __accessCheck$4 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$4 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _hasStarted, _startupTasks;
+class BackendPluginLifecycleImpl {
+  constructor(logger, rootLifecycle, pluginMetadata) {
+    this.logger = logger;
+    this.rootLifecycle = rootLifecycle;
+    this.pluginMetadata = pluginMetadata;
+    __privateAdd$4(this, _hasStarted, false);
+    __privateAdd$4(this, _startupTasks, []);
+  }
+  addStartupHook(hook, options) {
+    if (__privateGet$4(this, _hasStarted)) {
+      throw new Error("Attempted to add startup hook after startup");
+    }
+    __privateGet$4(this, _startupTasks).push({ hook, options });
+  }
+  async startup() {
+    if (__privateGet$4(this, _hasStarted)) {
+      return;
+    }
+    __privateSet$4(this, _hasStarted, true);
+    this.logger.debug(
+      `Running ${__privateGet$4(this, _startupTasks).length} plugin startup tasks...`
+    );
+    await Promise.all(
+      __privateGet$4(this, _startupTasks).map(async ({ hook, options }) => {
+        var _a;
+        const logger = (_a = options == null ? void 0 : options.logger) != null ? _a : this.logger;
+        try {
+          await hook();
+          logger.debug(`Plugin startup hook succeeded`);
+        } catch (error) {
+          logger.error(`Plugin startup hook failed, ${error}`);
+        }
+      })
+    );
+  }
+  addShutdownHook(hook, options) {
+    var _a, _b;
+    const plugin = this.pluginMetadata.getId();
+    this.rootLifecycle.addShutdownHook(hook, {
+      logger: (_b = (_a = options == null ? void 0 : options.logger) == null ? void 0 : _a.child({ plugin })) != null ? _b : this.logger
+    });
+  }
+}
+_hasStarted = new WeakMap();
+_startupTasks = new WeakMap();
+const lifecycleServiceFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.lifecycle,
+  deps: {
+    logger: backendPluginApi.coreServices.logger,
+    rootLifecycle: backendPluginApi.coreServices.rootLifecycle,
+    pluginMetadata: backendPluginApi.coreServices.pluginMetadata
+  },
+  async factory({ rootLifecycle, logger, pluginMetadata }) {
+    return new BackendPluginLifecycleImpl(
+      logger,
+      rootLifecycle,
+      pluginMetadata
+    );
+  }
+});
+
 var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -971,15 +1089,16 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$3(obj, member, "access private method");
   return method;
 };
-var _startPromise, _features, _registerInits, _extensionPoints, _serviceHolder, _getInitDeps, getInitDeps_fn, _doStart, doStart_fn, _resolveInitOrder, resolveInitOrder_fn;
+var _startPromise, _features, _extensionPoints, _serviceHolder, _getInitDeps, getInitDeps_fn, _doStart, doStart_fn, _getRootLifecycleImpl, getRootLifecycleImpl_fn, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn;
 class BackendInitializer {
   constructor(serviceHolder) {
     __privateAdd$3(this, _getInitDeps);
     __privateAdd$3(this, _doStart);
-    __privateAdd$3(this, _resolveInitOrder);
+    // Bit of a hacky way to grab the lifecycle services, potentially find a nicer way to do this
+    __privateAdd$3(this, _getRootLifecycleImpl);
+    __privateAdd$3(this, _getPluginLifecycleImpl);
     __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);
@@ -1028,20 +1147,12 @@ class BackendInitializer {
       return;
     }
     await __privateGet$3(this, _startPromise);
-    const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
-      backendPluginApi.coreServices.rootLifecycle,
-      "root"
-    );
-    if (lifecycleService instanceof BackendLifecycleImpl) {
-      await lifecycleService.shutdown();
-    } else {
-      throw new Error("Unexpected lifecycle service implementation");
-    }
+    const lifecycleService = await __privateMethod$2(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
+    await lifecycleService.shutdown();
   }
 }
 _startPromise = new WeakMap();
 _features = new WeakMap();
-_registerInits = new WeakMap();
 _extensionPoints = new WeakMap();
 _serviceHolder = new WeakMap();
 _getInitDeps = new WeakSet();
@@ -1081,6 +1192,8 @@ doStart_fn = async function() {
       await __privateGet$3(this, _serviceHolder).get(ref, "root");
     }
   }
+  const pluginInits = /* @__PURE__ */ new Map();
+  const moduleInits = /* @__PURE__ */ new Map();
   for (const feature of __privateGet$3(this, _features)) {
     for (const r of feature.getRegistrations()) {
       const provides = /* @__PURE__ */ new Set();
@@ -1095,19 +1208,68 @@ doStart_fn = async function() {
           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
-      });
+      if (r.type === "plugin") {
+        if (pluginInits.has(r.pluginId)) {
+          throw new Error(`Plugin '${r.pluginId}' is already registered`);
+        }
+        pluginInits.set(r.pluginId, {
+          provides,
+          consumes: new Set(Object.values(r.init.deps)),
+          init: r.init
+        });
+      } else {
+        let modules = moduleInits.get(r.pluginId);
+        if (!modules) {
+          modules = /* @__PURE__ */ new Map();
+          moduleInits.set(r.pluginId, modules);
+        }
+        if (modules.has(r.moduleId)) {
+          throw new Error(
+            `Module '${r.moduleId}' for plugin '${r.pluginId}' is already registered`
+          );
+        }
+        modules.set(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);
-  }
+  const allPluginIds = [
+    .../* @__PURE__ */ new Set([...pluginInits.keys(), ...moduleInits.keys()])
+  ];
+  await Promise.all(
+    allPluginIds.map(async (pluginId) => {
+      var _a;
+      const modules = (_a = moduleInits.get(pluginId)) != null ? _a : [];
+      await Promise.all(
+        Array.from(modules).map(async ([moduleId, moduleInit]) => {
+          const moduleDeps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, moduleInit.init.deps, pluginId);
+          await moduleInit.init.func(moduleDeps).catch((error) => {
+            throw new errors.ForwardedError(
+              `Module '${moduleId}' for plugin '${pluginId}' startup failed`,
+              error
+            );
+          });
+        })
+      );
+      const pluginInit = pluginInits.get(pluginId);
+      if (pluginInit) {
+        const pluginDeps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, pluginInit.init.deps, pluginId);
+        await pluginInit.init.func(pluginDeps).catch((error) => {
+          throw new errors.ForwardedError(
+            `Plugin '${pluginId}' startup failed`,
+            error
+          );
+        });
+      }
+      const lifecycleService2 = await __privateMethod$2(this, _getPluginLifecycleImpl, getPluginLifecycleImpl_fn).call(this, pluginId);
+      await lifecycleService2.startup();
+    })
+  );
+  const lifecycleService = await __privateMethod$2(this, _getRootLifecycleImpl, getRootLifecycleImpl_fn).call(this);
+  await lifecycleService.startup();
   if (process.env.NODE_ENV !== "test") {
     const rootLogger = await __privateGet$3(this, _serviceHolder).get(
       backendPluginApi.coreServices.rootLogger,
@@ -1123,29 +1285,27 @@ doStart_fn = async function() {
     });
   }
 };
-_resolveInitOrder = new WeakSet();
-resolveInitOrder_fn = function(registerInits) {
-  let registerInitsToOrder = registerInits.slice();
-  const orderedRegisterInits = new Array();
-  while (registerInitsToOrder.length > 0) {
-    const toRemove = /* @__PURE__ */ new Set();
-    for (const registerInit of registerInitsToOrder) {
-      const unInitializedDependents = [];
-      for (const provided of registerInit.provides) {
-        if (registerInitsToOrder.some(
-          (init) => init !== registerInit && init.consumes.has(provided)
-        )) {
-          unInitializedDependents.push(provided);
-        }
-      }
-      if (unInitializedDependents.length === 0) {
-        orderedRegisterInits.push(registerInit);
-        toRemove.add(registerInit);
-      }
-    }
-    registerInitsToOrder = registerInitsToOrder.filter((r) => !toRemove.has(r));
+_getRootLifecycleImpl = new WeakSet();
+getRootLifecycleImpl_fn = async function() {
+  const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
+    backendPluginApi.coreServices.rootLifecycle,
+    "root"
+  );
+  if (lifecycleService instanceof BackendLifecycleImpl) {
+    return lifecycleService;
+  }
+  throw new Error("Unexpected root lifecycle service implementation");
+};
+_getPluginLifecycleImpl = new WeakSet();
+getPluginLifecycleImpl_fn = async function(pluginId) {
+  const lifecycleService = await __privateGet$3(this, _serviceHolder).get(
+    backendPluginApi.coreServices.lifecycle,
+    pluginId
+  );
+  if (lifecycleService instanceof BackendPluginLifecycleImpl) {
+    return lifecycleService;
   }
-  return orderedRegisterInits;
+  throw new Error("Unexpected plugin lifecycle service implementation");
 };
 
 var __accessCheck$2 = (obj, member, msg) => {
@@ -1458,20 +1618,86 @@ const discoveryServiceFactory = backendPluginApi.createServiceFactory({
   }
 });
 
+const DEFAULT_TIMEOUT = { seconds: 5 };
+function durationToMs(duration) {
+  const {
+    years = 0,
+    months = 0,
+    weeks = 0,
+    days = 0,
+    hours = 0,
+    minutes = 0,
+    seconds = 0,
+    milliseconds = 0
+  } = duration;
+  const totalDays = years * 365 + months * 30 + weeks * 7 + days;
+  const totalHours = totalDays * 24 + hours;
+  const totalMinutes = totalHours * 60 + minutes;
+  const totalSeconds = totalMinutes * 60 + seconds;
+  const totalMilliseconds = totalSeconds * 1e3 + milliseconds;
+  return totalMilliseconds;
+}
+function createLifecycleMiddleware(options) {
+  const { lifecycle, startupRequestPauseTimeout = DEFAULT_TIMEOUT } = options;
+  let state = "init";
+  const waiting = /* @__PURE__ */ new Set();
+  lifecycle.addStartupHook(async () => {
+    if (state === "init") {
+      state = "up";
+      for (const item of waiting) {
+        clearTimeout(item.timeout);
+        item.next();
+      }
+      waiting.clear();
+    }
+  });
+  lifecycle.addShutdownHook(async () => {
+    state = "down";
+    for (const item of waiting) {
+      clearTimeout(item.timeout);
+      item.next(new errors.ServiceUnavailableError("Service is shutting down"));
+    }
+    waiting.clear();
+  });
+  const timeoutMs = durationToMs(startupRequestPauseTimeout);
+  return (_req, _res, next) => {
+    if (state === "up") {
+      next();
+      return;
+    } else if (state === "down") {
+      next(new errors.ServiceUnavailableError("Service is shutting down"));
+      return;
+    }
+    const item = {
+      next,
+      timeout: setTimeout(() => {
+        if (waiting.delete(item)) {
+          next(new errors.ServiceUnavailableError("Service has not started up yet"));
+        }
+      }, timeoutMs)
+    };
+    waiting.add(item);
+  };
+}
+
 const httpRouterServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.httpRouter,
     deps: {
       plugin: backendPluginApi.coreServices.pluginMetadata,
+      lifecycle: backendPluginApi.coreServices.lifecycle,
       rootHttpRouter: backendPluginApi.coreServices.rootHttpRouter
     },
-    async factory({ plugin, rootHttpRouter }) {
+    async factory({ plugin, rootHttpRouter, lifecycle }) {
       var _a;
       const getPath = (_a = options == null ? void 0 : options.getPath) != null ? _a : (id) => `/api/${id}`;
       const path = getPath(plugin.getId());
+      const router = PromiseRouter__default["default"]();
+      rootHttpRouter.use(path, router);
+      router.use(createLifecycleMiddleware({ lifecycle }));
       return {
         use(handler) {
-          rootHttpRouter.use(path, handler);
+          router.use(handler);
         }
       };
     }
@@ -1490,26 +1716,6 @@ const identityServiceFactory = backendPluginApi.createServiceFactory(
   })
 );
 
-const lifecycleServiceFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.lifecycle,
-  deps: {
-    logger: backendPluginApi.coreServices.logger,
-    rootLifecycle: backendPluginApi.coreServices.rootLifecycle,
-    pluginMetadata: backendPluginApi.coreServices.pluginMetadata
-  },
-  async factory({ rootLifecycle, logger, pluginMetadata }) {
-    const plugin = pluginMetadata.getId();
-    return {
-      addShutdownHook(hook, options) {
-        var _a, _b;
-        rootLifecycle.addShutdownHook(hook, {
-          logger: (_b = (_a = options == null ? void 0 : options.logger) == null ? void 0 : _a.child({ plugin })) != null ? _b : logger
-        });
-      }
-    };
-  }
-});
-
 const loggerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.logger,
   deps: {
@@ -1749,6 +1955,7 @@ exports.cacheServiceFactory = cacheServiceFactory;
 exports.configServiceFactory = configServiceFactory;
 exports.createConfigSecretEnumerator = createConfigSecretEnumerator;
 exports.createHttpServer = createHttpServer;
+exports.createLifecycleMiddleware = createLifecycleMiddleware;
 exports.createSpecializedBackend = createSpecializedBackend;
 exports.databaseServiceFactory = databaseServiceFactory;
 exports.discoveryServiceFactory = discoveryServiceFactory;