@backstage/backend-app-api 0.0.0-nightly-20230207022622 → 0.0.0-nightly-20230209023017

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")
     }
@@ -929,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
@@ -968,17 +968,28 @@ class BackendInitializer {
     __privateAdd$3(this, _doStart);
     __privateAdd$3(this, _resolveInitOrder);
     __privateAdd$3(this, _startPromise, void 0);
-    __privateAdd$3(this, _features, /* @__PURE__ */ new Map());
+    __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) {
+  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, _startPromise)) {
@@ -1060,44 +1071,32 @@ doStart_fn = async function() {
       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");
+  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);
         }
-        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}`
-      );
+      __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
+      });
     }
-    __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);
+    const deps = await __privateMethod$2(this, _getInitDeps, getInitDeps_fn).call(this, registerInit.init.deps, registerInit.id);
+    await registerInit.init.func(deps);
   }
 };
 _resolveInitOrder = new WeakSet();
@@ -1148,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);
@@ -1156,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());
   }
@@ -1166,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);
@@ -1181,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);
         }
@@ -1243,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;
@@ -1259,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);
     }
@@ -1356,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,
@@ -1370,17 +1385,19 @@ const cacheFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-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,
@@ -1404,7 +1421,7 @@ const databaseFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const discoveryFactory = backendPluginApi.createServiceFactory({
+const discoveryServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.discovery,
   deps: {
     config: backendPluginApi.coreServices.config
@@ -1414,7 +1431,7 @@ const discoveryFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const httpRouterFactory = backendPluginApi.createServiceFactory(
+const httpRouterServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.httpRouter,
     deps: {
@@ -1434,7 +1451,7 @@ const httpRouterFactory = backendPluginApi.createServiceFactory(
   })
 );
 
-const identityFactory = backendPluginApi.createServiceFactory(
+const identityServiceFactory = backendPluginApi.createServiceFactory(
   (options) => ({
     service: backendPluginApi.coreServices.identity,
     deps: {
@@ -1446,7 +1463,7 @@ const identityFactory = backendPluginApi.createServiceFactory(
   })
 );
 
-const lifecycleFactory = backendPluginApi.createServiceFactory({
+const lifecycleServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.lifecycle,
   deps: {
     logger: backendPluginApi.coreServices.logger,
@@ -1466,7 +1483,7 @@ const lifecycleFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const loggerFactory = backendPluginApi.createServiceFactory({
+const loggerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.logger,
   deps: {
     rootLogger: backendPluginApi.coreServices.rootLogger,
@@ -1477,7 +1494,7 @@ const loggerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const permissionsFactory = backendPluginApi.createServiceFactory({
+const permissionsServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.permissions,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1586,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());
@@ -1599,41 +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(() => server.stop());
-    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
@@ -1655,7 +1669,7 @@ const rootLoggerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const schedulerFactory = backendPluginApi.createServiceFactory({
+const schedulerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.scheduler,
   deps: {
     plugin: backendPluginApi.coreServices.pluginMetadata,
@@ -1671,7 +1685,7 @@ const schedulerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const tokenManagerFactory = backendPluginApi.createServiceFactory({
+const tokenManagerServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.tokenManager,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1687,7 +1701,7 @@ const tokenManagerFactory = backendPluginApi.createServiceFactory({
   }
 });
 
-const urlReaderFactory = backendPluginApi.createServiceFactory({
+const urlReaderServiceFactory = backendPluginApi.createServiceFactory({
   service: backendPluginApi.coreServices.urlReader,
   deps: {
     config: backendPluginApi.coreServices.config,
@@ -1704,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