@backstage/backend-app-api 0.3.0-next.1 → 0.3.0

package/dist/index.cjs.js

@@ -2,11 +2,16 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var path = require('path');
+var parseArgs = require('minimist');
+var cliCommon = require('@backstage/cli-common');
+var configLoader = require('@backstage/config-loader');
+var config = require('@backstage/config');
+var getPackages = require('@manypkg/get-packages');
 var http = require('http');
 var https = require('https');
 var stoppableServer = require('stoppable');
 var fs = require('fs-extra');
-var path = require('path');
 var forge = require('node-forge');
 var cors = require('cors');
 var helmet = require('helmet');
@@ -14,10 +19,13 @@ var morgan = require('morgan');
 var compression = require('compression');
 var minimatch = require('minimatch');
 var errors = require('@backstage/errors');
+var winston = require('winston');
 var backendPluginApi = require('@backstage/backend-plugin-api');
-var express = require('express');
 var backendCommon = require('@backstage/backend-common');
+var pluginAuthNode = require('@backstage/plugin-auth-node');
 var pluginPermissionNode = require('@backstage/plugin-permission-node');
+var express = require('express');
+var trimEnd = require('lodash/trimEnd');
 var backendTasks = require('@backstage/backend-tasks');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -40,6 +48,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var parseArgs__default = /*#__PURE__*/_interopDefaultLegacy(parseArgs);
 var http__namespace = /*#__PURE__*/_interopNamespace(http);
 var https__namespace = /*#__PURE__*/_interopNamespace(https);
 var stoppableServer__default = /*#__PURE__*/_interopDefaultLegacy(stoppableServer);
@@ -50,6 +59,187 @@ var helmet__default = /*#__PURE__*/_interopDefaultLegacy(helmet);
 var morgan__default = /*#__PURE__*/_interopDefaultLegacy(morgan);
 var compression__default = /*#__PURE__*/_interopDefaultLegacy(compression);
 var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
+var trimEnd__default = /*#__PURE__*/_interopDefaultLegacy(trimEnd);
+
+class ObservableConfigProxy {
+  constructor(parent, parentKey) {
+    this.parent = parent;
+    this.parentKey = parentKey;
+    this.config = new config.ConfigReader({});
+    this.subscribers = [];
+    if (parent && !parentKey) {
+      throw new Error("parentKey is required if parent is set");
+    }
+  }
+  setConfig(config) {
+    if (this.parent) {
+      throw new Error("immutable");
+    }
+    this.config = config;
+    for (const subscriber of this.subscribers) {
+      try {
+        subscriber();
+      } catch (error) {
+        console.error(`Config subscriber threw error, ${error}`);
+      }
+    }
+  }
+  subscribe(onChange) {
+    if (this.parent) {
+      return this.parent.subscribe(onChange);
+    }
+    this.subscribers.push(onChange);
+    return {
+      unsubscribe: () => {
+        const index = this.subscribers.indexOf(onChange);
+        if (index >= 0) {
+          this.subscribers.splice(index, 1);
+        }
+      }
+    };
+  }
+  select(required) {
+    var _a;
+    if (this.parent && this.parentKey) {
+      if (required) {
+        return this.parent.select(true).getConfig(this.parentKey);
+      }
+      return (_a = this.parent.select(false)) == null ? void 0 : _a.getOptionalConfig(this.parentKey);
+    }
+    return this.config;
+  }
+  has(key) {
+    var _a, _b;
+    return (_b = (_a = this.select(false)) == null ? void 0 : _a.has(key)) != null ? _b : false;
+  }
+  keys() {
+    var _a, _b;
+    return (_b = (_a = this.select(false)) == null ? void 0 : _a.keys()) != null ? _b : [];
+  }
+  get(key) {
+    return this.select(true).get(key);
+  }
+  getOptional(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptional(key);
+  }
+  getConfig(key) {
+    return new ObservableConfigProxy(this, key);
+  }
+  getOptionalConfig(key) {
+    var _a;
+    if ((_a = this.select(false)) == null ? void 0 : _a.has(key)) {
+      return new ObservableConfigProxy(this, key);
+    }
+    return void 0;
+  }
+  getConfigArray(key) {
+    return this.select(true).getConfigArray(key);
+  }
+  getOptionalConfigArray(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalConfigArray(key);
+  }
+  getNumber(key) {
+    return this.select(true).getNumber(key);
+  }
+  getOptionalNumber(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalNumber(key);
+  }
+  getBoolean(key) {
+    return this.select(true).getBoolean(key);
+  }
+  getOptionalBoolean(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalBoolean(key);
+  }
+  getString(key) {
+    return this.select(true).getString(key);
+  }
+  getOptionalString(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalString(key);
+  }
+  getStringArray(key) {
+    return this.select(true).getStringArray(key);
+  }
+  getOptionalStringArray(key) {
+    var _a;
+    return (_a = this.select(false)) == null ? void 0 : _a.getOptionalStringArray(key);
+  }
+}
+
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createConfigSecretEnumerator(options) {
+  const { logger, dir = process.cwd() } = options;
+  const { packages } = await getPackages.getPackages(dir);
+  const schema = await configLoader.loadConfigSchema({
+    dependencies: packages.map((p) => p.packageJson.name)
+  });
+  return (config) => {
+    var _a;
+    const [secretsData] = schema.process(
+      [{ data: (_a = config.getOptional()) != null ? _a : {}, context: "schema-enumerator" }],
+      {
+        visibility: ["secret"],
+        ignoreSchemaErrors: true
+      }
+    );
+    const secrets = /* @__PURE__ */ new Set();
+    JSON.parse(
+      JSON.stringify(secretsData),
+      (_, v) => typeof v === "string" && secrets.add(v)
+    );
+    logger.info(
+      `Found ${secrets.size} new secrets in config that will be redacted`
+    );
+    return secrets;
+  };
+}
+async function loadBackendConfig(options) {
+  var _a;
+  const args = parseArgs__default["default"](options.argv);
+  const configTargets = [(_a = args.config) != null ? _a : []].flat().map((arg) => isValidUrl(arg) ? { url: arg } : { path: path.resolve(arg) });
+  const paths = cliCommon.findPaths(__dirname);
+  let currentCancelFunc = void 0;
+  const config$1 = new ObservableConfigProxy();
+  const { appConfigs } = await configLoader.loadConfig({
+    configRoot: paths.targetRoot,
+    configTargets,
+    remote: options.remote,
+    watch: {
+      onChange(newConfigs) {
+        console.info(
+          `Reloaded config from ${newConfigs.map((c) => c.context).join(", ")}`
+        );
+        config$1.setConfig(config.ConfigReader.fromConfigs(newConfigs));
+      },
+      stopSignal: new Promise((resolve) => {
+        if (currentCancelFunc) {
+          currentCancelFunc();
+        }
+        currentCancelFunc = resolve;
+        if (module.hot) {
+          module.hot.addDisposeHandler(resolve);
+        }
+      })
+    }
+  });
+  console.info(
+    `Loaded config from ${appConfigs.map((c) => c.context).join(", ")}`
+  );
+  config$1.setConfig(config.ConfigReader.fromConfigs(appConfigs));
+  return { config: config$1 };
+}
 
 const DEFAULT_PORT = 7007;
 const DEFAULT_HOST = "";
@@ -337,7 +527,7 @@ function readCorsOptions(config) {
   if (!cc) {
     return { origin: false };
   }
-  return {
+  return removeUnknown({
     origin: createCorsOriginMatcher(readStringArray(cc, "origin")),
     methods: readStringArray(cc, "methods"),
     allowedHeaders: readStringArray(cc, "allowedHeaders"),
@@ -346,7 +536,12 @@ function readCorsOptions(config) {
     maxAge: cc.getOptionalNumber("maxAge"),
     preflightContinue: cc.getOptionalBoolean("preflightContinue"),
     optionsSuccessStatus: cc.getOptionalNumber("optionsSuccessStatus")
-  };
+  });
+}
+function removeUnknown(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, v]) => v !== void 0)
+  );
 }
 function readStringArray(config, key) {
   const value = config.getOptional(key);
@@ -372,31 +567,31 @@ function createCorsOriginMatcher(allowedOriginPatterns) {
   };
 }
 
-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 _config, _logger;
 const _MiddlewareFactory = class {
   constructor(options) {
-    __privateAdd$5(this, _config, void 0);
-    __privateAdd$5(this, _logger, void 0);
-    __privateSet$5(this, _config, options.config);
-    __privateSet$5(this, _logger, options.logger);
+    __privateAdd$6(this, _config, void 0);
+    __privateAdd$6(this, _logger, void 0);
+    __privateSet$6(this, _config, options.config);
+    __privateSet$6(this, _logger, options.logger);
   }
   /**
    * Creates a new {@link MiddlewareFactory}.
@@ -442,7 +637,7 @@ const _MiddlewareFactory = class {
    * @returns An Express request handler
    */
   logging() {
-    const logger = __privateGet$5(this, _logger).child({
+    const logger = __privateGet$6(this, _logger).child({
       type: "incomingRequest"
     });
     return morgan__default["default"]("combined", {
@@ -466,7 +661,7 @@ const _MiddlewareFactory = class {
    * @returns An Express request handler
    */
   helmet() {
-    return helmet__default["default"](readHelmetOptions(__privateGet$5(this, _config).getOptionalConfig("backend")));
+    return helmet__default["default"](readHelmetOptions(__privateGet$6(this, _config).getOptionalConfig("backend")));
   }
   /**
    * Returns a middleware that implements the cors library.
@@ -481,7 +676,7 @@ const _MiddlewareFactory = class {
    * @returns An Express request handler
    */
   cors() {
-    return cors__default["default"](readCorsOptions(__privateGet$5(this, _config).getOptionalConfig("backend")));
+    return cors__default["default"](readCorsOptions(__privateGet$6(this, _config).getOptionalConfig("backend")));
   }
   /**
    * Express middleware to handle errors during request processing.
@@ -506,7 +701,7 @@ const _MiddlewareFactory = class {
   error(options = {}) {
     var _a;
     const showStackTraces = (_a = options.showStackTraces) != null ? _a : process.env.NODE_ENV === "development";
-    const logger = __privateGet$5(this, _logger).child({
+    const logger = __privateGet$6(this, _logger).child({
       type: "errorHandler"
     });
     return (error, req, res, next) => {
@@ -556,6 +751,132 @@ function getStatusCode(error) {
   return 500;
 }
 
+var __accessCheck$5 = (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");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+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$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 _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);
+  }
+  /**
+   * Creates a {@link WinstonLogger} instance.
+   */
+  static create(options) {
+    var _a;
+    const redacter = _WinstonLogger.redacter();
+    let logger = winston.createLogger({
+      level: options.level,
+      format: winston.format.combine(redacter.format, options.format),
+      transports: (_a = options.transports) != null ? _a : new winston.transports.Console()
+    });
+    if (options.meta) {
+      logger = logger.child(options.meta);
+    }
+    return new _WinstonLogger(logger, redacter.add);
+  }
+  /**
+   * Creates a winston log formatter for redacting secrets.
+   */
+  static redacter() {
+    const redactionSet = /* @__PURE__ */ new Set();
+    let redactionPattern = void 0;
+    return {
+      format: winston.format((info) => {
+        if (redactionPattern && typeof info.message === "string") {
+          info.message = info.message.replace(redactionPattern, "[REDACTED]");
+        }
+        return info;
+      })(),
+      add(newRedactions) {
+        let added = 0;
+        for (const redaction of newRedactions) {
+          if (redaction.length <= 1) {
+            continue;
+          }
+          if (!redactionSet.has(redaction)) {
+            redactionSet.add(redaction);
+            added += 1;
+          }
+        }
+        if (added > 0) {
+          redactionPattern = new RegExp(
+            `(${Array.from(redactionSet).join("|")})`,
+            "g"
+          );
+        }
+      }
+    };
+  }
+  /**
+   * Creates a pretty printed winston log formatter.
+   */
+  static colorFormat() {
+    const colorizer = winston.format.colorize();
+    return winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.colorize({
+        colors: {
+          timestamp: "dim",
+          prefix: "blue",
+          field: "cyan",
+          debug: "grey"
+        }
+      }),
+      winston.format.printf((info) => {
+        const { timestamp, level, message, plugin, service, ...fields } = info;
+        const prefix = plugin || service;
+        const timestampColor = colorizer.colorize("timestamp", timestamp);
+        const prefixColor = colorizer.colorize("prefix", prefix);
+        const extraFields = Object.entries(fields).map(
+          ([key, value]) => `${colorizer.colorize("field", `${key}`)}=${value}`
+        ).join(" ");
+        return `${timestampColor} ${prefixColor} ${level} ${message} ${extraFields}`;
+      })
+    );
+  }
+  error(message, meta) {
+    __privateGet$5(this, _winston).error(message, meta);
+  }
+  warn(message, meta) {
+    __privateGet$5(this, _winston).warn(message, meta);
+  }
+  info(message, meta) {
+    __privateGet$5(this, _winston).info(message, meta);
+  }
+  debug(message, meta) {
+    __privateGet$5(this, _winston).debug(message, meta);
+  }
+  child(meta) {
+    return new _WinstonLogger(__privateGet$5(this, _winston).child(meta));
+  }
+  addRedactions(redactions) {
+    var _a;
+    (_a = __privateGet$5(this, _addRedactions)) == null ? void 0 : _a.call(this, redactions);
+  }
+};
+let WinstonLogger = _WinstonLogger;
+_winston = new WeakMap();
+_addRedactions = new WeakMap();
+
 var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -804,7 +1125,7 @@ var __privateMethod$1 = (obj, member, method) => {
   __accessCheck$2(obj, member, "access private method");
   return method;
 };
-var _providedFactories, _loadedDefaultFactories, _implementations, _resolveFactory, resolveFactory_fn, _separateMapForTheRootService, _checkForMissingDeps, checkForMissingDeps_fn;
+var _providedFactories, _loadedDefaultFactories, _implementations, _rootServiceImplementations, _resolveFactory, resolveFactory_fn, _checkForMissingDeps, checkForMissingDeps_fn;
 class ServiceRegistry {
   constructor(factories) {
     __privateAdd$2(this, _resolveFactory);
@@ -812,7 +1133,7 @@ class ServiceRegistry {
     __privateAdd$2(this, _providedFactories, void 0);
     __privateAdd$2(this, _loadedDefaultFactories, void 0);
     __privateAdd$2(this, _implementations, void 0);
-    __privateAdd$2(this, _separateMapForTheRootService, /* @__PURE__ */ new Map());
+    __privateAdd$2(this, _rootServiceImplementations, /* @__PURE__ */ new Map());
     __privateSet$2(this, _providedFactories, new Map(factories.map((f) => [f.service.id, f])));
     __privateSet$2(this, _loadedDefaultFactories, /* @__PURE__ */ new Map());
     __privateSet$2(this, _implementations, /* @__PURE__ */ new Map());
@@ -824,7 +1145,7 @@ class ServiceRegistry {
     var _a;
     return (_a = __privateMethod$1(this, _resolveFactory, resolveFactory_fn).call(this, ref, pluginId)) == null ? void 0 : _a.then((factory) => {
       if (factory.scope === "root") {
-        let existing = __privateGet$2(this, _separateMapForTheRootService).get(factory);
+        let existing = __privateGet$2(this, _rootServiceImplementations).get(factory);
         if (!existing) {
           __privateMethod$1(this, _checkForMissingDeps, checkForMissingDeps_fn).call(this, factory, pluginId);
           const rootDeps = new Array();
@@ -840,7 +1161,7 @@ class ServiceRegistry {
           existing = Promise.all(rootDeps).then(
             (entries) => factory.factory(Object.fromEntries(entries))
           );
-          __privateGet$2(this, _separateMapForTheRootService).set(factory, existing);
+          __privateGet$2(this, _rootServiceImplementations).set(factory, existing);
         }
         return existing;
       }
@@ -855,10 +1176,15 @@ class ServiceRegistry {
           }
         }
         implementation = {
-          factoryFunc: Promise.all(rootDeps).then((entries) => factory.factory(Object.fromEntries(entries))).catch((error) => {
+          context: Promise.all(rootDeps).then(
+            (entries) => {
+              var _a2;
+              return (_a2 = factory.createRootContext) == null ? void 0 : _a2.call(factory, Object.fromEntries(entries));
+            }
+          ).catch((error) => {
             const cause = errors.stringifyError(error);
             throw new Error(
-              `Failed to instantiate service '${ref.id}' because the top-level factory function threw an error, ${cause}`
+              `Failed to instantiate service '${ref.id}' because createRootContext threw an error, ${cause}`
             );
           }),
           byPlugin: /* @__PURE__ */ new Map()
@@ -872,9 +1198,9 @@ class ServiceRegistry {
           const target = this.get(serviceRef, pluginId);
           allDeps.push(target.then((impl) => [name, impl]));
         }
-        result = implementation.factoryFunc.then(
-          (func) => Promise.all(allDeps).then(
-            (entries) => func(Object.fromEntries(entries))
+        result = implementation.context.then(
+          (context) => Promise.all(allDeps).then(
+            (entries) => factory.factory(Object.fromEntries(entries), context)
           )
         ).catch((error) => {
           const cause = errors.stringifyError(error);
@@ -891,6 +1217,7 @@ class ServiceRegistry {
 _providedFactories = new WeakMap();
 _loadedDefaultFactories = new WeakMap();
 _implementations = new WeakMap();
+_rootServiceImplementations = new WeakMap();
 _resolveFactory = new WeakSet();
 resolveFactory_fn = function(ref, pluginId) {
   if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
@@ -898,11 +1225,7 @@ resolveFactory_fn = function(ref, pluginId) {
       scope: "plugin",
       service: backendPluginApi.coreServices.pluginMetadata,
       deps: {},
-      factory: async () => async () => ({
-        getId() {
-          return pluginId;
-        }
-      })
+      factory: async () => ({ getId: () => pluginId })
     });
   }
   let resolvedFactory = __privateGet$2(this, _providedFactories).get(ref.id);
@@ -928,7 +1251,6 @@ resolveFactory_fn = function(ref, pluginId) {
   }
   return Promise.resolve(resolvedFactory);
 };
-_separateMapForTheRootService = new WeakMap();
 _checkForMissingDeps = new WeakSet();
 checkForMissingDeps_fn = function(factory, pluginId) {
   const missingDeps = Object.values(factory.deps).filter((ref) => {
@@ -1012,26 +1334,139 @@ function createSpecializedBackend(options) {
   return new BackstageBackend(services);
 }
 
-const httpRouterFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.httpRouter,
+const cacheFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.cache,
   deps: {
-    plugin: backendPluginApi.coreServices.pluginMetadata,
-    rootHttpRouter: backendPluginApi.coreServices.rootHttpRouter
+    config: backendPluginApi.coreServices.config,
+    plugin: backendPluginApi.coreServices.pluginMetadata
   },
-  async factory({ rootHttpRouter }, options) {
-    var _a;
-    const getPath = (_a = options == null ? void 0 : options.getPath) != null ? _a : (id) => `/api/${id}`;
-    return async ({ plugin }) => {
+  async createRootContext({ config }) {
+    return backendCommon.CacheManager.fromConfig(config);
+  },
+  async factory({ plugin }, manager) {
+    return manager.forPlugin(plugin.getId());
+  }
+});
+
+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 databaseFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.database,
+  deps: {
+    config: backendPluginApi.coreServices.config,
+    plugin: backendPluginApi.coreServices.pluginMetadata
+  },
+  async createRootContext({ config: config$1 }) {
+    return config$1.getOptional("backend.database") ? backendCommon.DatabaseManager.fromConfig(config$1) : backendCommon.DatabaseManager.fromConfig(
+      new config.ConfigReader({
+        backend: {
+          database: { client: "better-sqlite3", connection: ":memory:" }
+        }
+      })
+    );
+  },
+  async factory({ plugin }, databaseManager) {
+    return databaseManager.forPlugin(plugin.getId());
+  }
+});
+
+const discoveryFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.discovery,
+  deps: {
+    config: backendPluginApi.coreServices.config
+  },
+  async factory({ config }) {
+    return backendCommon.SingleHostDiscovery.fromConfig(config);
+  }
+});
+
+const httpRouterFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.httpRouter,
+    deps: {
+      plugin: backendPluginApi.coreServices.pluginMetadata,
+      rootHttpRouter: backendPluginApi.coreServices.rootHttpRouter
+    },
+    async factory({ plugin, rootHttpRouter }) {
+      var _a;
+      const getPath = (_a = options == null ? void 0 : options.getPath) != null ? _a : (id) => `/api/${id}`;
       const path = getPath(plugin.getId());
       return {
         use(handler) {
           rootHttpRouter.use(path, handler);
         }
       };
+    }
+  })
+);
+
+const identityFactory = backendPluginApi.createServiceFactory(
+  (options) => ({
+    service: backendPluginApi.coreServices.identity,
+    deps: {
+      discovery: backendPluginApi.coreServices.discovery
+    },
+    async factory({ discovery }) {
+      return pluginAuthNode.DefaultIdentityClient.create({ discovery, ...options });
+    }
+  })
+);
+
+const lifecycleFactory = 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(options) {
+        var _a, _b;
+        rootLifecycle.addShutdownHook({
+          ...options,
+          logger: (_b = (_a = options.logger) == null ? void 0 : _a.child({ plugin })) != null ? _b : logger
+        });
+      }
     };
   }
 });
 
+const loggerFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.logger,
+  deps: {
+    rootLogger: backendPluginApi.coreServices.rootLogger,
+    plugin: backendPluginApi.coreServices.pluginMetadata
+  },
+  factory({ rootLogger, plugin }) {
+    return rootLogger.child({ plugin: plugin.getId() });
+  }
+});
+
+const permissionsFactory = backendPluginApi.createServiceFactory({
+  service: backendPluginApi.coreServices.permissions,
+  deps: {
+    config: backendPluginApi.coreServices.config,
+    discovery: backendPluginApi.coreServices.discovery,
+    tokenManager: backendPluginApi.coreServices.tokenManager
+  },
+  async factory({ config, discovery, tokenManager }) {
+    return pluginPermissionNode.ServerPermissionClient.fromConfig(config, {
+      discovery,
+      tokenManager
+    });
+  }
+});
+
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -1056,9 +1491,9 @@ var __privateMethod = (obj, member, method) => {
 };
 var _indexPath, _router, _namedRoutes, _indexRouter, _existingPaths, _findConflictingPath, findConflictingPath_fn;
 function normalizePath(path) {
-  return path.replace(/\/*$/, "/");
+  return `${trimEnd__default["default"](path, "/")}/`;
 }
-class RestrictedIndexedRouter {
+const _DefaultRootHttpRouter = class {
   constructor(indexPath) {
     __privateAdd(this, _findConflictingPath);
     __privateAdd(this, _indexPath, void 0);
@@ -1068,7 +1503,22 @@ class RestrictedIndexedRouter {
     __privateAdd(this, _existingPaths, new Array());
     __privateSet(this, _indexPath, indexPath);
     __privateGet(this, _router).use(__privateGet(this, _namedRoutes));
-    __privateGet(this, _router).use(__privateGet(this, _indexRouter));
+    if (__privateGet(this, _indexPath)) {
+      __privateGet(this, _router).use(__privateGet(this, _indexRouter));
+    }
+  }
+  static create(options) {
+    let indexPath;
+    if ((options == null ? void 0 : options.indexPath) === false) {
+      indexPath = void 0;
+    } else if ((options == null ? void 0 : options.indexPath) === void 0) {
+      indexPath = "/api/app";
+    } else if ((options == null ? void 0 : options.indexPath) === "") {
+      throw new Error("indexPath option may not be an empty string");
+    } else {
+      indexPath = options.indexPath;
+    }
+    return new _DefaultRootHttpRouter(indexPath);
   }
   use(path, handler) {
     if (path.match(/^[/\s]*$/)) {
@@ -1089,7 +1539,8 @@ class RestrictedIndexedRouter {
   handler() {
     return __privateGet(this, _router);
   }
-}
+};
+let DefaultRootHttpRouter = _DefaultRootHttpRouter;
 _indexPath = new WeakMap();
 _router = new WeakMap();
 _namedRoutes = new WeakMap();
@@ -1134,9 +1585,9 @@ const rootHttpRouterFactory = backendPluginApi.createServiceFactory({
     indexPath,
     configure = defaultConfigure
   } = {}) {
-    const router = new RestrictedIndexedRouter(indexPath != null ? indexPath : "/api/app");
     const logger = rootLogger.child({ service: "rootHttpRouter" });
     const app = express__default["default"]();
+    const router = DefaultRootHttpRouter.create({ indexPath });
     const middleware = MiddlewareFactory.create({ config, logger });
     configure({
       app,
@@ -1162,133 +1613,41 @@ const rootHttpRouterFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const cacheFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.cache,
-  deps: {
-    config: backendPluginApi.coreServices.config,
-    plugin: backendPluginApi.coreServices.pluginMetadata
-  },
-  async factory({ config }) {
-    const cacheManager = backendCommon.CacheManager.fromConfig(config);
-    return async ({ plugin }) => {
-      return cacheManager.forPlugin(plugin.getId());
-    };
-  }
-});
-
-const configFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.config,
-  deps: {
-    logger: backendPluginApi.coreServices.rootLogger
-  },
-  async factory({ logger }) {
-    const config = await backendCommon.loadBackendConfig({
-      argv: process.argv,
-      logger: backendCommon.loggerToWinstonLogger(logger)
-    });
-    return config;
-  }
-});
-
-const databaseFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.database,
-  deps: {
-    config: backendPluginApi.coreServices.config,
-    plugin: backendPluginApi.coreServices.pluginMetadata
-  },
-  async factory({ config }) {
-    const databaseManager = backendCommon.DatabaseManager.fromConfig(config);
-    return async ({ plugin }) => {
-      return databaseManager.forPlugin(plugin.getId());
-    };
-  }
-});
-
-const discoveryFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.discovery,
-  deps: {
-    config: backendPluginApi.coreServices.config
-  },
-  async factory({ config }) {
-    const discovery = backendCommon.SingleHostDiscovery.fromConfig(config);
-    return async () => {
-      return discovery;
-    };
-  }
-});
-
-const loggerFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.logger,
-  deps: {
-    rootLogger: backendPluginApi.coreServices.rootLogger,
-    plugin: backendPluginApi.coreServices.pluginMetadata
-  },
-  async factory({ rootLogger }) {
-    return async ({ plugin }) => {
-      return rootLogger.child({ plugin: plugin.getId() });
-    };
-  }
-});
-
-class BackstageLogger {
-  constructor(winston) {
-    this.winston = winston;
-  }
-  static fromWinston(logger) {
-    return new BackstageLogger(logger);
-  }
-  error(message, meta) {
-    this.winston.error(message, meta);
-  }
-  warn(message, meta) {
-    this.winston.warn(message, meta);
-  }
-  info(message, meta) {
-    this.winston.info(message, meta);
-  }
-  debug(message, meta) {
-    this.winston.debug(message, meta);
-  }
-  child(meta) {
-    return new BackstageLogger(this.winston.child(meta));
-  }
-}
 const rootLoggerFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.rootLogger,
-  deps: {},
-  async factory() {
-    return BackstageLogger.fromWinston(backendCommon.createRootLogger());
-  }
-});
-
-const permissionsFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.permissions,
   deps: {
-    config: backendPluginApi.coreServices.config,
-    discovery: backendPluginApi.coreServices.discovery,
-    tokenManager: backendPluginApi.coreServices.tokenManager
+    config: backendPluginApi.coreServices.config
   },
   async factory({ config }) {
-    return async ({ discovery, tokenManager }) => {
-      return pluginPermissionNode.ServerPermissionClient.fromConfig(config, {
-        discovery,
-        tokenManager
-      });
-    };
+    var _a;
+    const logger = WinstonLogger.create({
+      meta: {
+        service: "backstage"
+      },
+      level: process.env.LOG_LEVEL || "info",
+      format: process.env.NODE_ENV === "production" ? winston.format.json() : WinstonLogger.colorFormat(),
+      transports: [new winston.transports.Console()]
+    });
+    const secretEnumerator = await createConfigSecretEnumerator({ logger });
+    logger.addRedactions(secretEnumerator(config));
+    (_a = config.subscribe) == null ? void 0 : _a.call(config, () => logger.addRedactions(secretEnumerator(config)));
+    return logger;
   }
 });
 
 const schedulerFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.scheduler,
   deps: {
-    config: backendPluginApi.coreServices.config,
-    plugin: backendPluginApi.coreServices.pluginMetadata
+    plugin: backendPluginApi.coreServices.pluginMetadata,
+    databaseManager: backendPluginApi.coreServices.database,
+    logger: backendPluginApi.coreServices.logger
   },
-  async factory({ config }) {
-    const taskScheduler = backendTasks.TaskScheduler.fromConfig(config);
-    return async ({ plugin }) => {
-      return taskScheduler.forPlugin(plugin.getId());
-    };
+  async factory({ plugin, databaseManager, logger }) {
+    return backendTasks.TaskScheduler.forPlugin({
+      pluginId: plugin.getId(),
+      databaseManager,
+      logger: backendCommon.loggerToWinstonLogger(logger)
+    });
   }
 });
 
@@ -1296,14 +1655,15 @@ const tokenManagerFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.tokenManager,
   deps: {
     config: backendPluginApi.coreServices.config,
-    logger: backendPluginApi.coreServices.logger
+    logger: backendPluginApi.coreServices.rootLogger
   },
-  async factory() {
-    return async ({ config, logger }) => {
-      return backendCommon.ServerTokenManager.fromConfig(config, {
-        logger: backendCommon.loggerToWinstonLogger(logger)
-      });
-    };
+  createRootContext({ config, logger }) {
+    return backendCommon.ServerTokenManager.fromConfig(config, {
+      logger
+    });
+  },
+  async factory(_deps, tokenManager) {
+    return tokenManager;
   }
 });
 
@@ -1313,48 +1673,28 @@ const urlReaderFactory = backendPluginApi.createServiceFactory({
     config: backendPluginApi.coreServices.config,
     logger: backendPluginApi.coreServices.logger
   },
-  async factory() {
-    return async ({ config, logger }) => {
-      return backendCommon.UrlReaders.default({
-        config,
-        logger: backendCommon.loggerToWinstonLogger(logger)
-      });
-    };
-  }
-});
-
-const lifecycleFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.lifecycle,
-  deps: {
-    logger: backendPluginApi.coreServices.logger,
-    rootLifecycle: backendPluginApi.coreServices.rootLifecycle,
-    pluginMetadata: backendPluginApi.coreServices.pluginMetadata
-  },
-  async factory({ rootLifecycle }) {
-    return async ({ logger, pluginMetadata }) => {
-      const plugin = pluginMetadata.getId();
-      return {
-        addShutdownHook(options) {
-          var _a, _b;
-          rootLifecycle.addShutdownHook({
-            ...options,
-            logger: (_b = (_a = options.logger) == null ? void 0 : _a.child({ plugin })) != null ? _b : logger
-          });
-        }
-      };
-    };
+  async factory({ config, logger }) {
+    return backendCommon.UrlReaders.default({
+      config,
+      logger: backendCommon.loggerToWinstonLogger(logger)
+    });
   }
 });
 
+exports.DefaultRootHttpRouter = DefaultRootHttpRouter;
 exports.MiddlewareFactory = MiddlewareFactory;
+exports.WinstonLogger = WinstonLogger;
 exports.cacheFactory = cacheFactory;
 exports.configFactory = configFactory;
+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.loadBackendConfig = loadBackendConfig;
 exports.loggerFactory = loggerFactory;
 exports.permissionsFactory = permissionsFactory;
 exports.readCorsOptions = readCorsOptions;