@backstage/backend-app-api 0.8.1-next.1 → 0.8.1-next.2

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @backstage/backend-app-api
 
+## 0.8.1-next.2
+
+### Patch Changes
+
+- 8b13183: Added support for the latest version of `BackendFeature`s from `@backstage/backend-plugin-api`, including feature loaders.
+- 93095ee: Make sure node-fetch is version 2.7.0 or greater
+- 7c5f3b0: Update the `ServiceRegister` implementation to enable registering multiple service implementations for a given service ref.
+- 80a0737: Added configuration for the `packages` options to config schema
+- Updated dependencies
+  - @backstage/backend-plugin-api@0.8.0-next.2
+  - @backstage/backend-common@0.23.4-next.2
+  - @backstage/config-loader@1.9.0-next.2
+  - @backstage/plugin-auth-node@0.5.0-next.2
+  - @backstage/plugin-permission-node@0.8.1-next.2
+  - @backstage/backend-tasks@0.5.28-next.2
+  - @backstage/cli-node@0.2.7
+  - @backstage/cli-common@0.1.14
+  - @backstage/config@1.2.0
+  - @backstage/errors@1.2.4
+  - @backstage/types@1.1.1
+
 ## 0.8.1-next.1
 
 ### Patch Changes

package/alpha/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backstage/backend-app-api__alpha",
-  "version": "0.8.1-next.1",
+  "version": "0.8.1-next.2",
   "main": "../dist/alpha.cjs.js",
   "types": "../dist/alpha.d.ts"
 }

package/config.d.ts

@@ -287,6 +287,7 @@ export interface Config {
           }
       >;
     };
+    packages?: 'all' | { include?: string[]; exclude?: string[] };
   };
 
   /** Discovery options. */

package/dist/alpha.d.ts

@@ -2,6 +2,6 @@ import * as _backstage_backend_plugin_api from '@backstage/backend-plugin-api';
 import { FeatureDiscoveryService } from '@backstage/backend-plugin-api/alpha';
 
 /** @alpha */
-declare const featureDiscoveryServiceFactory: _backstage_backend_plugin_api.ServiceFactoryCompat<FeatureDiscoveryService, "root", undefined>;
+declare const featureDiscoveryServiceFactory: _backstage_backend_plugin_api.ServiceFactoryCompat<FeatureDiscoveryService, "root", "singleton", undefined>;
 
 export { featureDiscoveryServiceFactory };

package/dist/index.cjs.js

@@ -1243,7 +1243,19 @@ function createPluginMetadataServiceFactory(pluginId) {
 }
 class ServiceRegistry {
   static create(factories) {
-    const registry = new ServiceRegistry(factories);
+    const factoryMap = /* @__PURE__ */ new Map();
+    for (const factory of factories) {
+      if (factory.service.multiton) {
+        const existing = factoryMap.get(factory.service.id) ?? [];
+        factoryMap.set(
+          factory.service.id,
+          existing.concat(toInternalServiceFactory(factory))
+        );
+      } else {
+        factoryMap.set(factory.service.id, [toInternalServiceFactory(factory)]);
+      }
+    }
+    const registry = new ServiceRegistry(factoryMap);
     registry.checkForCircularDeps();
     return registry;
   }
@@ -1254,17 +1266,15 @@ class ServiceRegistry {
   #addedFactoryIds = /* @__PURE__ */ new Set();
   #instantiatedFactories = /* @__PURE__ */ new Set();
   constructor(factories) {
-    this.#providedFactories = new Map(
-      factories.map((sf) => [sf.service.id, toInternalServiceFactory(sf)])
-    );
+    this.#providedFactories = factories;
     this.#loadedDefaultFactories = /* @__PURE__ */ new Map();
     this.#implementations = /* @__PURE__ */ new Map();
   }
   #resolveFactory(ref, pluginId) {
     if (ref.id === backendPluginApi.coreServices.pluginMetadata.id) {
-      return Promise.resolve(
+      return Promise.resolve([
         toInternalServiceFactory(createPluginMetadataServiceFactory(pluginId))
-      );
+      ]);
     }
     let resolvedFactory = this.#providedFactories.get(ref.id);
     const { __defaultFactory: defaultFactory } = ref;
@@ -1279,13 +1289,16 @@ class ServiceRegistry {
         );
         this.#loadedDefaultFactories.set(defaultFactory, loadedFactory);
       }
-      resolvedFactory = loadedFactory.catch((error) => {
-        throw new Error(
-          `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
-            error
-          )}`
-        );
-      });
+      resolvedFactory = loadedFactory.then(
+        (factory) => [factory],
+        (error) => {
+          throw new Error(
+            `Failed to instantiate service '${ref.id}' because the default factory loader threw an error, ${errors.stringifyError(
+              error
+            )}`
+          );
+        }
+      );
     }
     return Promise.resolve(resolvedFactory);
   }
@@ -1297,6 +1310,9 @@ class ServiceRegistry {
       if (this.#providedFactories.get(ref.id)) {
         return false;
       }
+      if (ref.multiton) {
+        return false;
+      }
       return !ref.__defaultFactory;
     });
     if (missingDeps.length) {
@@ -1308,13 +1324,13 @@ class ServiceRegistry {
   }
   checkForCircularDeps() {
     const graph = DependencyGraph.fromIterable(
-      Array.from(this.#providedFactories).map(
-        ([serviceId, serviceFactory]) => ({
-          value: serviceId,
-          provides: [serviceId],
-          consumes: Object.values(serviceFactory.deps).map((d) => d.id)
-        })
-      )
+      Array.from(this.#providedFactories).map(([serviceId, factories]) => ({
+        value: serviceId,
+        provides: [serviceId],
+        consumes: factories.flatMap(
+          (factory) => Object.values(factory.deps).map((d) => d.id)
+        )
+      }))
     );
     const circularDependencies = Array.from(graph.detectCircularDependencies());
     if (circularDependencies.length) {
@@ -1330,21 +1346,28 @@ class ServiceRegistry {
         `The ${backendPluginApi.coreServices.pluginMetadata.id} service cannot be overridden`
       );
     }
-    if (this.#addedFactoryIds.has(factoryId)) {
-      throw new Error(
-        `Duplicate service implementations provided for ${factoryId}`
-      );
-    }
     if (this.#instantiatedFactories.has(factoryId)) {
       throw new Error(
         `Unable to set service factory with id ${factoryId}, service has already been instantiated`
       );
     }
-    this.#addedFactoryIds.add(factoryId);
-    this.#providedFactories.set(factoryId, toInternalServiceFactory(factory));
+    if (factory.service.multiton) {
+      const newFactories = (this.#providedFactories.get(factoryId) ?? []).concat(toInternalServiceFactory(factory));
+      this.#providedFactories.set(factoryId, newFactories);
+    } else {
+      if (this.#addedFactoryIds.has(factoryId)) {
+        throw new Error(
+          `Duplicate service implementations provided for ${factoryId}`
+        );
+      }
+      this.#addedFactoryIds.add(factoryId);
+      this.#providedFactories.set(factoryId, [
+        toInternalServiceFactory(factory)
+      ]);
+    }
   }
   async initializeEagerServicesWithScope(scope, pluginId = "root") {
-    for (const factory of this.#providedFactories.values()) {
+    for (const [factory] of this.#providedFactories.values()) {
       if (factory.service.scope === scope) {
         if (scope === "root" && factory.initialization !== "lazy") {
           await this.get(factory.service, pluginId);
@@ -1356,72 +1379,80 @@ class ServiceRegistry {
   }
   get(ref, pluginId) {
     this.#instantiatedFactories.add(ref.id);
-    return this.#resolveFactory(ref, pluginId)?.then((factory) => {
-      if (factory.service.scope === "root") {
-        let existing = this.#rootServiceImplementations.get(factory);
-        if (!existing) {
-          this.#checkForMissingDeps(factory, pluginId);
-          const rootDeps = new Array();
-          for (const [name, serviceRef] of Object.entries(factory.deps)) {
-            if (serviceRef.scope !== "root") {
-              throw new Error(
-                `Failed to instantiate 'root' scoped service '${ref.id}' because it depends on '${serviceRef.scope}' scoped service '${serviceRef.id}'.`
+    const resolvedFactory = this.#resolveFactory(ref, pluginId);
+    if (!resolvedFactory) {
+      return ref.multiton ? Promise.resolve([]) : void 0;
+    }
+    return resolvedFactory.then((factories) => {
+      return Promise.all(
+        factories.map((factory) => {
+          if (factory.service.scope === "root") {
+            let existing = this.#rootServiceImplementations.get(factory);
+            if (!existing) {
+              this.#checkForMissingDeps(factory, pluginId);
+              const rootDeps = new Array();
+              for (const [name, serviceRef] of Object.entries(factory.deps)) {
+                if (serviceRef.scope !== "root") {
+                  throw new Error(
+                    `Failed to instantiate 'root' scoped service '${ref.id}' because it depends on '${serviceRef.scope}' scoped service '${serviceRef.id}'.`
+                  );
+                }
+                const target = this.get(serviceRef, pluginId);
+                rootDeps.push(target.then((impl) => [name, impl]));
+              }
+              existing = Promise.all(rootDeps).then(
+                (entries) => factory.factory(Object.fromEntries(entries), void 0)
               );
+              this.#rootServiceImplementations.set(factory, existing);
             }
-            const target = this.get(serviceRef, pluginId);
-            rootDeps.push(target.then((impl) => [name, impl]));
+            return existing;
           }
-          existing = Promise.all(rootDeps).then(
-            (entries) => factory.factory(Object.fromEntries(entries), void 0)
-          );
-          this.#rootServiceImplementations.set(factory, existing);
-        }
-        return existing;
-      }
-      let implementation = this.#implementations.get(factory);
-      if (!implementation) {
-        this.#checkForMissingDeps(factory, pluginId);
-        const rootDeps = new Array();
-        for (const [name, serviceRef] of Object.entries(factory.deps)) {
-          if (serviceRef.scope === "root") {
-            const target = this.get(serviceRef, pluginId);
-            rootDeps.push(target.then((impl) => [name, impl]));
+          let implementation = this.#implementations.get(factory);
+          if (!implementation) {
+            this.#checkForMissingDeps(factory, pluginId);
+            const rootDeps = new Array();
+            for (const [name, serviceRef] of Object.entries(factory.deps)) {
+              if (serviceRef.scope === "root") {
+                const target = this.get(serviceRef, pluginId);
+                rootDeps.push(target.then((impl) => [name, impl]));
+              }
+            }
+            implementation = {
+              context: Promise.all(rootDeps).then(
+                (entries) => factory.createRootContext?.(Object.fromEntries(entries))
+              ).catch((error) => {
+                const cause = errors.stringifyError(error);
+                throw new Error(
+                  `Failed to instantiate service '${ref.id}' because createRootContext threw an error, ${cause}`
+                );
+              }),
+              byPlugin: /* @__PURE__ */ new Map()
+            };
+            this.#implementations.set(factory, implementation);
           }
-        }
-        implementation = {
-          context: Promise.all(rootDeps).then(
-            (entries) => factory.createRootContext?.(Object.fromEntries(entries))
-          ).catch((error) => {
-            const cause = errors.stringifyError(error);
-            throw new Error(
-              `Failed to instantiate service '${ref.id}' because createRootContext threw an error, ${cause}`
-            );
-          }),
-          byPlugin: /* @__PURE__ */ new Map()
-        };
-        this.#implementations.set(factory, implementation);
-      }
-      let result = implementation.byPlugin.get(pluginId);
-      if (!result) {
-        const allDeps = new Array();
-        for (const [name, serviceRef] of Object.entries(factory.deps)) {
-          const target = this.get(serviceRef, pluginId);
-          allDeps.push(target.then((impl) => [name, impl]));
-        }
-        result = implementation.context.then(
-          (context) => Promise.all(allDeps).then(
-            (entries) => factory.factory(Object.fromEntries(entries), context)
-          )
-        ).catch((error) => {
-          const cause = errors.stringifyError(error);
-          throw new Error(
-            `Failed to instantiate service '${ref.id}' for '${pluginId}' because the factory function threw an error, ${cause}`
-          );
-        });
-        implementation.byPlugin.set(pluginId, result);
-      }
-      return result;
-    });
+          let result = implementation.byPlugin.get(pluginId);
+          if (!result) {
+            const allDeps = new Array();
+            for (const [name, serviceRef] of Object.entries(factory.deps)) {
+              const target = this.get(serviceRef, pluginId);
+              allDeps.push(target.then((impl) => [name, impl]));
+            }
+            result = implementation.context.then(
+              (context) => Promise.all(allDeps).then(
+                (entries) => factory.factory(Object.fromEntries(entries), context)
+              )
+            ).catch((error) => {
+              const cause = errors.stringifyError(error);
+              throw new Error(
+                `Failed to instantiate service '${ref.id}' for '${pluginId}' because the factory function threw an error, ${cause}`
+              );
+            });
+            implementation.byPlugin.set(pluginId, result);
+          }
+          return result;
+        })
+      );
+    }).then((results) => ref.multiton ? results : results[0]);
   }
 }
 
@@ -1473,10 +1504,11 @@ function createInitializationLogger(pluginIds, rootLogger) {
 
 class BackendInitializer {
   #startPromise;
-  #features = new Array();
+  #registrations = new Array();
   #extensionPoints = /* @__PURE__ */ new Map();
   #serviceRegistry;
   #registeredFeatures = new Array();
+  #registeredFeatureLoaders = new Array();
   constructor(defaultApiFactories) {
     this.#serviceRegistry = ServiceRegistry.create([...defaultApiFactories]);
   }
@@ -1519,20 +1551,12 @@ class BackendInitializer {
     this.#registeredFeatures.push(Promise.resolve(feature));
   }
   #addFeature(feature) {
-    if (feature.$$type !== "@backstage/BackendFeature") {
-      throw new Error(
-        `Failed to add feature, invalid type '${feature.$$type}'`
-      );
-    }
     if (isServiceFactory(feature)) {
       this.#serviceRegistry.add(feature);
-    } else if (isInternalBackendFeature(feature)) {
-      if (feature.version !== "v1") {
-        throw new Error(
-          `Failed to add feature, invalid version '${feature.version}'`
-        );
-      }
-      this.#features.push(feature);
+    } else if (isBackendFeatureLoader(feature)) {
+      this.#registeredFeatureLoaders.push(feature);
+    } else if (isBackendRegistrations(feature)) {
+      this.#registrations.push(feature);
     } else {
       throw new Error(
         `Failed to add feature, invalid feature ${JSON.stringify(feature)}`
@@ -1577,10 +1601,11 @@ class BackendInitializer {
       }
       this.#serviceRegistry.checkForCircularDeps();
     }
+    await this.#applyBackendFeatureLoaders(this.#registeredFeatureLoaders);
     await this.#serviceRegistry.initializeEagerServicesWithScope("root");
     const pluginInits = /* @__PURE__ */ new Map();
     const moduleInits = /* @__PURE__ */ new Map();
-    for (const feature of this.#features) {
+    for (const feature of this.#registrations) {
       for (const r of feature.getRegistrations()) {
         const provides = /* @__PURE__ */ new Set();
         if (r.type === "plugin" || r.type === "module") {
@@ -1606,7 +1631,7 @@ class BackendInitializer {
             consumes: new Set(Object.values(r.init.deps)),
             init: r.init
           });
-        } else {
+        } else if (r.type === "module") {
           let modules = moduleInits.get(r.pluginId);
           if (!modules) {
             modules = /* @__PURE__ */ new Map();
@@ -1622,6 +1647,8 @@ class BackendInitializer {
             consumes: new Set(Object.values(r.init.deps)),
             init: r.init
           });
+        } else {
+          throw new Error(`Invalid registration type '${r.type}'`);
         }
       }
     }
@@ -1738,12 +1765,85 @@ class BackendInitializer {
     }
     throw new Error("Unexpected plugin lifecycle service implementation");
   }
+  async #applyBackendFeatureLoaders(loaders) {
+    for (const loader of loaders) {
+      const deps = /* @__PURE__ */ new Map();
+      const missingRefs = /* @__PURE__ */ new Set();
+      for (const [name, ref] of Object.entries(loader.deps ?? {})) {
+        if (ref.scope !== "root") {
+          throw new Error(
+            `Feature loaders can only depend on root scoped services, but '${name}' is scoped to '${ref.scope}'. Offending loader is ${loader.description}`
+          );
+        }
+        const impl = await this.#serviceRegistry.get(
+          ref,
+          "root"
+        );
+        if (impl) {
+          deps.set(name, impl);
+        } else {
+          missingRefs.add(ref);
+        }
+      }
+      if (missingRefs.size > 0) {
+        const missing = Array.from(missingRefs).join(", ");
+        throw new Error(
+          `No service available for the following ref(s): ${missing}, depended on by feature loader ${loader.description}`
+        );
+      }
+      const result = await loader.loader(Object.fromEntries(deps)).catch((error) => {
+        throw new errors.ForwardedError(
+          `Feature loader ${loader.description} failed`,
+          error
+        );
+      });
+      let didAddServiceFactory = false;
+      const newLoaders = new Array();
+      for await (const feature of result) {
+        if (isBackendFeatureLoader(feature)) {
+          newLoaders.push(feature);
+        } else {
+          didAddServiceFactory ||= isServiceFactory(feature);
+          this.#addFeature(feature);
+        }
+      }
+      if (didAddServiceFactory) {
+        this.#serviceRegistry.checkForCircularDeps();
+      }
+      if (newLoaders.length > 0) {
+        await this.#applyBackendFeatureLoaders(newLoaders);
+      }
+    }
+  }
+}
+function toInternalBackendFeature(feature) {
+  if (feature.$$type !== "@backstage/BackendFeature") {
+    throw new Error(`Invalid BackendFeature, bad type '${feature.$$type}'`);
+  }
+  const internal = feature;
+  if (internal.version !== "v1") {
+    throw new Error(
+      `Invalid BackendFeature, bad version '${internal.version}'`
+    );
+  }
+  return internal;
 }
 function isServiceFactory(feature) {
-  return !!feature.service;
+  const internal = toInternalBackendFeature(feature);
+  if (internal.featureType === "service") {
+    return true;
+  }
+  return "service" in internal;
+}
+function isBackendRegistrations(feature) {
+  const internal = toInternalBackendFeature(feature);
+  if (internal.featureType === "registrations") {
+    return true;
+  }
+  return "getRegistrations" in internal;
 }
-function isInternalBackendFeature(feature) {
-  return typeof feature.getRegistrations === "function";
+function isBackendFeatureLoader(feature) {
+  return toInternalBackendFeature(feature).featureType === "loader";
 }
 
 class BackstageBackend {