@backstage/backend-dynamic-feature-service 0.4.2-next.1 → 0.4.2

package/dist/index.cjs.js

@@ -1,698 +1,23 @@
 'use strict';
 
-var fs$1 = require('fs/promises');
-var fs = require('fs');
-var chokidar = require('chokidar');
-var path = require('path');
-var url = require('url');
-var debounce = require('lodash/debounce');
-var cliNode = require('@backstage/cli-node');
-var backendPluginApi = require('@backstage/backend-plugin-api');
-var cliCommon = require('@backstage/cli-common');
-var alpha = require('@backstage/backend-plugin-api/alpha');
-var fs$2 = require('fs-extra');
-var lodash = require('lodash');
-var configLoader = require('@backstage/config-loader');
-var pluginAppNode = require('@backstage/plugin-app-node');
-var rootLogger = require('@backstage/backend-defaults/rootLogger');
-var winston = require('winston');
-var backendCommon = require('@backstage/backend-common');
-var getPackages = require('@manypkg/get-packages');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
-
-function _interopNamespaceCompat(e) {
-  if (e && typeof e === 'object' && 'default' in e) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs$1);
-var fs__namespace$1 = /*#__PURE__*/_interopNamespaceCompat(fs);
-var chokidar__namespace = /*#__PURE__*/_interopNamespaceCompat(chokidar);
-var path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
-var url__namespace = /*#__PURE__*/_interopNamespaceCompat(url);
-var debounce__default = /*#__PURE__*/_interopDefaultCompat(debounce);
-var fs__default = /*#__PURE__*/_interopDefaultCompat(fs$2);
-
-function isBackendDynamicPluginInstaller(obj) {
-  return obj !== void 0 && "kind" in obj && (obj.kind === "new" || obj.kind === "legacy");
-}
-
-class PluginScanner {
-  constructor(config, logger, backstageRoot, preferAlpha) {
-    this.config = config;
-    this.logger = logger;
-    this.backstageRoot = backstageRoot;
-    this.preferAlpha = preferAlpha;
-  }
-  _rootDirectory;
-  configUnsubscribe;
-  rootDirectoryWatcher;
-  subscribers = [];
-  static create(options) {
-    const scanner = new PluginScanner(
-      options.config,
-      options.logger,
-      options.backstageRoot,
-      options.preferAlpha || false
-    );
-    scanner.applyConfig();
-    return scanner;
-  }
-  subscribeToRootDirectoryChange(subscriber) {
-    this.subscribers.push(subscriber);
-  }
-  get rootDirectory() {
-    return this._rootDirectory;
-  }
-  applyConfig() {
-    const dynamicPlugins = this.config.getOptional("dynamicPlugins");
-    if (!dynamicPlugins) {
-      this.logger.info("'dynamicPlugins' config entry not found.");
-      this._rootDirectory = void 0;
-      return;
-    }
-    if (typeof dynamicPlugins !== "object") {
-      this.logger.warn("'dynamicPlugins' config entry should be an object.");
-      this._rootDirectory = void 0;
-      return;
-    }
-    if (!("rootDirectory" in dynamicPlugins)) {
-      this.logger.warn(
-        "'dynamicPlugins' config entry does not contain the 'rootDirectory' field."
-      );
-      this._rootDirectory = void 0;
-      return;
-    }
-    if (typeof dynamicPlugins.rootDirectory !== "string") {
-      this.logger.warn(
-        "'dynamicPlugins.rootDirectory' config entry should be a string."
-      );
-      this._rootDirectory = void 0;
-      return;
-    }
-    const dynamicPluginsRootPath = path__namespace.isAbsolute(dynamicPlugins.rootDirectory) ? path__namespace.resolve(dynamicPlugins.rootDirectory) : path__namespace.resolve(this.backstageRoot, dynamicPlugins.rootDirectory);
-    if (!path__namespace.dirname(dynamicPluginsRootPath).startsWith(path__namespace.resolve(this.backstageRoot))) {
-      const nodePath = process.env.NODE_PATH;
-      const backstageNodeModules = path__namespace.resolve(
-        this.backstageRoot,
-        "node_modules"
-      );
-      if (!nodePath || !nodePath.split(path__namespace.delimiter).includes(backstageNodeModules)) {
-        throw new Error(
-          `Dynamic plugins under '${dynamicPluginsRootPath}' cannot access backstage modules in '${backstageNodeModules}'.
-Please add '${backstageNodeModules}' to the 'NODE_PATH' when running the backstage backend.`
-        );
-      }
-    }
-    if (!fs.lstatSync(dynamicPluginsRootPath).isDirectory()) {
-      throw new Error("Not a directory");
-    }
-    this._rootDirectory = dynamicPluginsRootPath;
-  }
-  async scanRoot() {
-    if (!this._rootDirectory) {
-      return { packages: [] };
-    }
-    const dynamicPluginsLocation = this._rootDirectory;
-    const scannedPlugins = [];
-    for (const dirEnt of await fs__namespace.readdir(dynamicPluginsLocation, {
-      withFileTypes: true
-    })) {
-      const pluginDir = dirEnt;
-      if (pluginDir.name === "lost+found") {
-        this.logger.debug(`skipping '${pluginDir.name}' system directory`);
-        continue;
-      }
-      const pluginHome = path__namespace.normalize(
-        path__namespace.resolve(dynamicPluginsLocation, pluginDir.name)
-      );
-      if (dirEnt.isSymbolicLink()) {
-        if (!(await fs__namespace.lstat(await fs__namespace.readlink(pluginHome))).isDirectory()) {
-          this.logger.info(
-            `skipping '${pluginHome}' since it is not a directory`
-          );
-          continue;
-        }
-      } else if (!dirEnt.isDirectory()) {
-        this.logger.info(
-          `skipping '${pluginHome}' since it is not a directory`
-        );
-        continue;
-      }
-      let scannedPlugin;
-      let platform;
-      try {
-        scannedPlugin = await this.scanDir(pluginHome);
-        if (!scannedPlugin.manifest.main) {
-          throw new Error("field 'main' not found in 'package.json'");
-        }
-        if (scannedPlugin.manifest.backstage?.role) {
-          platform = cliNode.PackageRoles.getRoleInfo(
-            scannedPlugin.manifest.backstage.role
-          ).platform;
-        } else {
-          throw new Error("field 'backstage.role' not found in 'package.json'");
-        }
-      } catch (e) {
-        this.logger.error(
-          `failed to load dynamic plugin manifest from '${pluginHome}'`,
-          e
-        );
-        continue;
-      }
-      if (platform === "node") {
-        if (this.preferAlpha) {
-          const pluginHomeAlpha = path__namespace.resolve(pluginHome, "alpha");
-          if (fs.existsSync(pluginHomeAlpha)) {
-            if ((await fs__namespace.lstat(pluginHomeAlpha)).isDirectory()) {
-              const backstage = scannedPlugin.manifest.backstage;
-              try {
-                scannedPlugin = await this.scanDir(pluginHomeAlpha);
-              } catch (e) {
-                this.logger.error(
-                  `failed to load dynamic plugin manifest from '${pluginHomeAlpha}'`,
-                  e
-                );
-                continue;
-              }
-              scannedPlugin.manifest.backstage = backstage;
-            } else {
-              this.logger.warn(
-                `skipping '${pluginHomeAlpha}' since it is not a directory`
-              );
-            }
-          }
-        }
-      }
-      scannedPlugins.push(scannedPlugin);
-    }
-    return { packages: scannedPlugins };
-  }
-  async scanDir(pluginHome) {
-    const manifestFile = path__namespace.resolve(pluginHome, "package.json");
-    const content = await fs__namespace.readFile(manifestFile);
-    const manifest = JSON.parse(content.toString());
-    return {
-      location: url__namespace.pathToFileURL(pluginHome),
-      manifest
-    };
-  }
-  async trackChanges() {
-    const setupRootDirectoryWatcher = async () => {
-      return new Promise((resolve, reject) => {
-        if (!this._rootDirectory) {
-          resolve();
-          return;
-        }
-        const callSubscribers = debounce__default.default(() => {
-          this.subscribers.forEach((s) => s());
-        }, 500);
-        let ready = false;
-        this.rootDirectoryWatcher = chokidar__namespace.watch(this._rootDirectory, {
-          ignoreInitial: true,
-          followSymlinks: true,
-          depth: 1,
-          disableGlobbing: true
-        }).on(
-          "all",
-          (event, eventPath, _) => {
-            if (["addDir", "unlinkDir"].includes(event) && path__namespace.dirname(eventPath) === this._rootDirectory || ["add", "unlink", "change"].includes(event) && path__namespace.dirname(path__namespace.dirname(eventPath)) === this._rootDirectory && path__namespace.basename(eventPath) === "package.json") {
-              this.logger.info(
-                `rootDirectory changed (${event} - ${eventPath}): scanning plugins again`
-              );
-              callSubscribers();
-            } else {
-              this.logger.debug(
-                `rootDirectory changed (${event} - ${eventPath}): no need to scan plugins again`
-              );
-            }
-          }
-        ).on("error", (error) => {
-          this.logger.error(
-            `error while watching '${this.rootDirectory}'`,
-            error
-          );
-          if (!ready) {
-            reject(error);
-          }
-        }).on("ready", () => {
-          ready = true;
-          resolve();
-        });
-      });
-    };
-    await setupRootDirectoryWatcher();
-    if (this.config.subscribe) {
-      const { unsubscribe } = this.config.subscribe(async () => {
-        const oldRootDirectory = this._rootDirectory;
-        try {
-          this.applyConfig();
-        } catch (e) {
-          this.logger.error(
-            "failed to apply new config for dynamic plugins",
-            e
-          );
-        }
-        if (oldRootDirectory !== this._rootDirectory) {
-          this.logger.info(
-            `rootDirectory changed in Config from '${oldRootDirectory}' to '${this._rootDirectory}'`
-          );
-          this.subscribers.forEach((s) => s());
-          if (this.rootDirectoryWatcher) {
-            await this.rootDirectoryWatcher.close();
-          }
-          await setupRootDirectoryWatcher();
-        }
-      });
-      this.configUnsubscribe = unsubscribe;
-    }
-  }
-  async untrackChanges() {
-    if (this.rootDirectoryWatcher) {
-      this.rootDirectoryWatcher.close();
-    }
-    if (this.configUnsubscribe) {
-      this.configUnsubscribe();
-    }
-  }
-  destructor() {
-    this.untrackChanges();
-  }
-}
-
-class CommonJSModuleLoader {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  async bootstrap(backstageRoot, dynamicPluginsPaths) {
-    const backstageRootNodeModulesPath = `${backstageRoot}/node_modules`;
-    const dynamicNodeModulesPaths = [
-      ...dynamicPluginsPaths.map((p) => path__namespace.default.resolve(p, "node_modules"))
-    ];
-    const Module = require("module");
-    const oldNodeModulePaths = Module._nodeModulePaths;
-    Module._nodeModulePaths = (from) => {
-      const result = oldNodeModulePaths(from);
-      if (!dynamicPluginsPaths.some((p) => from.startsWith(p))) {
-        return result;
-      }
-      const filtered = result.filter((nodeModulePath) => {
-        return nodeModulePath === backstageRootNodeModulesPath || dynamicNodeModulesPaths.some((p) => nodeModulePath.startsWith(p));
-      });
-      this.logger.debug(
-        `Overriding node_modules search path for dynamic plugin ${from} to: ${filtered}`
-      );
-      return filtered;
-    };
-  }
-  async load(packagePath) {
-    return await require(
-      /* webpackIgnore: true */
-      packagePath
-    );
-  }
-}
-
-class DynamicPluginManager {
-  constructor(logger, packages, moduleLoader) {
-    this.logger = logger;
-    this.packages = packages;
-    this.moduleLoader = moduleLoader;
-    this._plugins = [];
-    this._availablePackages = packages;
-  }
-  static async create(options) {
-    const backstageRoot = cliCommon.findPaths(__dirname).targetRoot;
-    const scanner = PluginScanner.create({
-      config: options.config,
-      logger: options.logger,
-      backstageRoot,
-      preferAlpha: options.preferAlpha
-    });
-    const scannedPlugins = (await scanner.scanRoot()).packages;
-    scanner.trackChanges();
-    const moduleLoader = options.moduleLoader || new CommonJSModuleLoader(options.logger);
-    const manager = new DynamicPluginManager(
-      options.logger,
-      scannedPlugins,
-      moduleLoader
-    );
-    const dynamicPluginsPaths = scannedPlugins.map(
-      (p) => fs__namespace$1.realpathSync(
-        path__namespace.default.dirname(
-          path__namespace.default.dirname(
-            path__namespace.default.resolve(url__namespace.fileURLToPath(p.location), p.manifest.main)
-          )
-        )
-      )
-    );
-    moduleLoader.bootstrap(backstageRoot, dynamicPluginsPaths);
-    scanner.subscribeToRootDirectoryChange(async () => {
-      manager._availablePackages = (await scanner.scanRoot()).packages;
-    });
-    manager._plugins.push(...await manager.loadPlugins());
-    return manager;
-  }
-  _plugins;
-  _availablePackages;
-  get availablePackages() {
-    return this._availablePackages;
-  }
-  addBackendPlugin(plugin) {
-    this._plugins.push(plugin);
-  }
-  async loadPlugins() {
-    const loadedPlugins = [];
-    for (const scannedPlugin of this.packages) {
-      const platform = cliNode.PackageRoles.getRoleInfo(
-        scannedPlugin.manifest.backstage.role
-      ).platform;
-      if (platform === "node" && scannedPlugin.manifest.backstage.role.includes("-plugin")) {
-        const plugin = await this.loadBackendPlugin(scannedPlugin);
-        if (plugin !== void 0) {
-          loadedPlugins.push(plugin);
-        }
-      } else {
-        loadedPlugins.push({
-          name: scannedPlugin.manifest.name,
-          version: scannedPlugin.manifest.version,
-          role: scannedPlugin.manifest.backstage.role,
-          platform: "web"
-          // TODO(davidfestal): add required front-end plugin information here.
-        });
-      }
-    }
-    return loadedPlugins;
-  }
-  async loadBackendPlugin(plugin) {
-    const packagePath = url__namespace.fileURLToPath(
-      `${plugin.location}/${plugin.manifest.main}`
-    );
-    try {
-      const pluginModule = await this.moduleLoader.load(packagePath);
-      let dynamicPluginInstaller;
-      if (isBackendFeature(pluginModule.default)) {
-        dynamicPluginInstaller = {
-          kind: "new",
-          install: () => pluginModule.default
-        };
-      } else if (isBackendFeatureFactory(pluginModule.default)) {
-        dynamicPluginInstaller = {
-          kind: "new",
-          install: pluginModule.default
-        };
-      } else {
-        dynamicPluginInstaller = pluginModule.dynamicPluginInstaller;
-      }
-      if (!isBackendDynamicPluginInstaller(dynamicPluginInstaller)) {
-        this.logger.error(
-          `dynamic backend plugin '${plugin.manifest.name}' could not be loaded from '${plugin.location}': the module should either export a 'BackendFeature' or 'BackendFeatureFactory' as default export, or export a 'const dynamicPluginInstaller: BackendDynamicPluginInstaller' field as dynamic loading entrypoint.`
-        );
-        return void 0;
-      }
-      this.logger.info(
-        `loaded dynamic backend plugin '${plugin.manifest.name}' from '${plugin.location}'`
-      );
-      return {
-        name: plugin.manifest.name,
-        version: plugin.manifest.version,
-        platform: "node",
-        role: plugin.manifest.backstage.role,
-        installer: dynamicPluginInstaller
-      };
-    } catch (error) {
-      this.logger.error(
-        `an error occurred while loading dynamic backend plugin '${plugin.manifest.name}' from '${plugin.location}'`,
-        error
-      );
-      return void 0;
-    }
-  }
-  backendPlugins() {
-    return this._plugins.filter(
-      (p) => p.platform === "node"
-    );
-  }
-  frontendPlugins() {
-    return this._plugins.filter(
-      (p) => p.platform === "web"
-    );
-  }
-  plugins() {
-    return this._plugins;
-  }
-}
-const dynamicPluginsServiceRef = backendPluginApi.createServiceRef(
-  {
-    id: "core.dynamicplugins",
-    scope: "root"
-  }
-);
-const dynamicPluginsServiceFactoryWithOptions = (options) => backendPluginApi.createServiceFactory({
-  service: dynamicPluginsServiceRef,
-  deps: {
-    config: backendPluginApi.coreServices.rootConfig,
-    logger: backendPluginApi.coreServices.rootLogger
-  },
-  async factory({ config, logger }) {
-    return await DynamicPluginManager.create({
-      config,
-      logger,
-      preferAlpha: true,
-      moduleLoader: options?.moduleLoader?.(logger)
-    });
-  }
-});
-const dynamicPluginsServiceFactory = dynamicPluginsServiceFactoryWithOptions();
-class DynamicPluginsEnabledFeatureDiscoveryService {
-  constructor(dynamicPlugins, featureDiscoveryService) {
-    this.dynamicPlugins = dynamicPlugins;
-    this.featureDiscoveryService = featureDiscoveryService;
-  }
-  async getBackendFeatures() {
-    const staticFeatures = (await this.featureDiscoveryService?.getBackendFeatures())?.features ?? [];
-    return {
-      features: [
-        ...this.dynamicPlugins.backendPlugins().flatMap((plugin) => {
-          if (plugin.installer.kind === "new") {
-            const installed = plugin.installer.install();
-            if (Array.isArray(installed)) {
-              return installed;
-            }
-            return [installed];
-          }
-          return [];
-        }),
-        ...staticFeatures
-      ]
-    };
-  }
-}
-const dynamicPluginsFeatureDiscoveryServiceFactory = backendPluginApi.createServiceFactory({
-  service: alpha.featureDiscoveryServiceRef,
-  deps: {
-    config: backendPluginApi.coreServices.rootConfig,
-    dynamicPlugins: dynamicPluginsServiceRef
-  },
-  factory({ dynamicPlugins }) {
-    return new DynamicPluginsEnabledFeatureDiscoveryService(dynamicPlugins);
-  }
-});
-const dynamicPluginsFeatureDiscoveryLoaderWithOptions = (options) => backendPluginApi.createBackendFeatureLoader({
-  deps: {
-    config: backendPluginApi.coreServices.rootConfig,
-    logger: backendPluginApi.coreServices.rootLogger
-  },
-  async loader({ config, logger }) {
-    const manager = await DynamicPluginManager.create({
-      config,
-      logger,
-      preferAlpha: true,
-      moduleLoader: options?.moduleLoader?.(logger)
-    });
-    const service = new DynamicPluginsEnabledFeatureDiscoveryService(manager);
-    const { features } = await service.getBackendFeatures();
-    return features;
-  }
-});
-const dynamicPluginsFeatureDiscoveryLoader = Object.assign(
-  dynamicPluginsFeatureDiscoveryLoaderWithOptions,
-  dynamicPluginsFeatureDiscoveryLoaderWithOptions()
-);
-function isBackendFeature(value) {
-  return !!value && (typeof value === "object" || typeof value === "function") && value.$$type === "@backstage/BackendFeature";
-}
-function isBackendFeatureFactory(value) {
-  return !!value && typeof value === "function" && value.$$type === "@backstage/BackendFeatureFactory";
-}
-
-const dynamicPluginsSchemasServiceRef = backendPluginApi.createServiceRef({
-  id: "core.dynamicplugins.schemas",
-  scope: "root"
-});
-const dynamicPluginsSchemasServiceFactoryWithOptions = (options) => backendPluginApi.createServiceFactory({
-  service: dynamicPluginsSchemasServiceRef,
-  deps: {
-    config: backendPluginApi.coreServices.rootConfig
-  },
-  factory({ config }) {
-    let additionalSchemas;
-    return {
-      async addDynamicPluginsSchemas(configSchema) {
-        if (!additionalSchemas) {
-          const logger = {
-            ...console,
-            child() {
-              return this;
-            }
-          };
-          const scanner = PluginScanner.create({
-            config,
-            logger,
-            // eslint-disable-next-line no-restricted-syntax
-            backstageRoot: cliCommon.findPaths(__dirname).targetRoot,
-            preferAlpha: true
-          });
-          const { packages } = await scanner.scanRoot();
-          additionalSchemas = await gatherDynamicPluginsSchemas(
-            packages,
-            logger,
-            options?.schemaLocator
-          );
-        }
-        const serialized = configSchema.serialize();
-        if (serialized?.backstageConfigSchemaVersion !== 1) {
-          throw new Error(
-            "Serialized configuration schema is invalid or has an invalid version number"
-          );
-        }
-        const schemas = serialized.schemas;
-        schemas.push(
-          ...Object.keys(additionalSchemas).map((context) => {
-            return {
-              path: context,
-              value: additionalSchemas[context]
-            };
-          })
-        );
-        serialized.schemas = schemas;
-        return {
-          schema: await configLoader.loadConfigSchema({
-            serialized
-          })
-        };
-      }
-    };
-  }
-});
-const dynamicPluginsSchemasServiceFactory = dynamicPluginsSchemasServiceFactoryWithOptions();
-async function gatherDynamicPluginsSchemas(packages, logger, schemaLocator = () => path__namespace.join("dist", "configSchema.json")) {
-  const allSchemas = {};
-  for (const pluginPackage of packages) {
-    let schemaLocation = schemaLocator(pluginPackage);
-    if (!path__namespace.isAbsolute(schemaLocation)) {
-      let pluginLocation = url__namespace.fileURLToPath(pluginPackage.location);
-      if (path__namespace.basename(pluginLocation) === "alpha") {
-        pluginLocation = path__namespace.dirname(pluginLocation);
-      }
-      schemaLocation = path__namespace.resolve(pluginLocation, schemaLocation);
-    }
-    if (!await fs__default.default.pathExists(schemaLocation)) {
-      continue;
-    }
-    const serialized = await fs__default.default.readJson(schemaLocation);
-    if (!serialized) {
-      continue;
-    }
-    if (lodash.isEmpty(serialized)) {
-      continue;
-    }
-    if (!serialized?.$schema || serialized?.type !== "object") {
-      logger.error(
-        `Serialized configuration schema is invalid for plugin ${pluginPackage.manifest.name}`
-      );
-      continue;
-    }
-    allSchemas[schemaLocation] = serialized;
-  }
-  return allSchemas;
-}
-
-const dynamicPluginsFrontendSchemas = backendPluginApi.createBackendModule({
-  pluginId: "app",
-  moduleId: "core.dynamicplugins.frontendSchemas",
-  register(reg) {
-    reg.registerInit({
-      deps: {
-        config: backendPluginApi.coreServices.rootConfig,
-        schemas: dynamicPluginsSchemasServiceRef,
-        configSchemaExtension: pluginAppNode.configSchemaExtensionPoint
-      },
-      async init({ config, schemas, configSchemaExtension }) {
-        const appPackageName = config.getOptionalString("app.packageName") ?? "app";
-        const appDistDir = backendPluginApi.resolvePackagePath(appPackageName, "dist");
-        const compiledConfigSchema = await pluginAppNode.loadCompiledConfigSchema(appDistDir);
-        if (compiledConfigSchema) {
-          configSchemaExtension.setConfigSchema(
-            (await schemas.addDynamicPluginsSchemas(compiledConfigSchema)).schema
-          );
-        }
-      }
-    });
-  }
-});
-
-const dynamicPluginsRootLoggerServiceFactory = backendPluginApi.createServiceFactory({
-  service: backendPluginApi.coreServices.rootLogger,
-  deps: {
-    config: backendPluginApi.coreServices.rootConfig,
-    schemas: dynamicPluginsSchemasServiceRef
-  },
-  async factory({ config, schemas }) {
-    const logger = rootLogger.WinstonLogger.create({
-      meta: {
-        service: "backstage"
-      },
-      level: process.env.LOG_LEVEL || "info",
-      format: process.env.NODE_ENV === "production" ? winston.format.json() : rootLogger.WinstonLogger.colorFormat(),
-      transports: [new winston.transports.Console()]
-    });
-    const configSchema = await configLoader.loadConfigSchema({
-      dependencies: (await getPackages.getPackages(process.cwd())).packages.map((p) => p.packageJson.name)
-    });
-    const secretEnumerator = await backendCommon.createConfigSecretEnumerator({
-      logger,
-      schema: (await schemas.addDynamicPluginsSchemas(configSchema)).schema
-    });
-    logger.addRedactions(secretEnumerator(config));
-    config.subscribe?.(() => logger.addRedactions(secretEnumerator(config)));
-    return logger;
-  }
-});
-
-exports.DynamicPluginManager = DynamicPluginManager;
-exports.dynamicPluginsFeatureDiscoveryLoader = dynamicPluginsFeatureDiscoveryLoader;
-exports.dynamicPluginsFeatureDiscoveryServiceFactory = dynamicPluginsFeatureDiscoveryServiceFactory;
-exports.dynamicPluginsFrontendSchemas = dynamicPluginsFrontendSchemas;
-exports.dynamicPluginsRootLoggerServiceFactory = dynamicPluginsRootLoggerServiceFactory;
-exports.dynamicPluginsSchemasServiceFactory = dynamicPluginsSchemasServiceFactory;
-exports.dynamicPluginsSchemasServiceFactoryWithOptions = dynamicPluginsSchemasServiceFactoryWithOptions;
-exports.dynamicPluginsServiceFactory = dynamicPluginsServiceFactory;
-exports.dynamicPluginsServiceFactoryWithOptions = dynamicPluginsServiceFactoryWithOptions;
-exports.dynamicPluginsServiceRef = dynamicPluginsServiceRef;
-exports.isBackendDynamicPluginInstaller = isBackendDynamicPluginInstaller;
+var types = require('./manager/types.cjs.js');
+var pluginManager = require('./manager/plugin-manager.cjs.js');
+var schemas = require('./schemas/schemas.cjs.js');
+var frontend = require('./schemas/frontend.cjs.js');
+var rootLogger = require('./schemas/rootLogger.cjs.js');
+var features = require('./features/features.cjs.js');
+
+
+
+exports.isBackendDynamicPluginInstaller = types.isBackendDynamicPluginInstaller;
+exports.DynamicPluginManager = pluginManager.DynamicPluginManager;
+exports.dynamicPluginsFeatureDiscoveryLoader = pluginManager.dynamicPluginsFeatureDiscoveryLoader;
+exports.dynamicPluginsFeatureDiscoveryServiceFactory = pluginManager.dynamicPluginsFeatureDiscoveryServiceFactory;
+exports.dynamicPluginsServiceFactory = pluginManager.dynamicPluginsServiceFactory;
+exports.dynamicPluginsServiceFactoryWithOptions = pluginManager.dynamicPluginsServiceFactoryWithOptions;
+exports.dynamicPluginsServiceRef = pluginManager.dynamicPluginsServiceRef;
+exports.dynamicPluginsSchemasServiceFactory = schemas.dynamicPluginsSchemasServiceFactory;
+exports.dynamicPluginsFrontendSchemas = frontend.dynamicPluginsFrontendSchemas;
+exports.dynamicPluginsRootLoggerServiceFactory = rootLogger.dynamicPluginsRootLoggerServiceFactory;
+exports.dynamicPluginsFeatureLoader = features.dynamicPluginsFeatureLoader;
 //# sourceMappingURL=index.cjs.js.map