@backstage/backend-test-utils 0.4.5-next.0 → 0.4.5-next.2

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @backstage/backend-test-utils
 
+## 0.4.5-next.2
+
+### Patch Changes
+
+- 8b13183: Internal updates to support latest version of `BackendFeauture`s from `@backstage/backend-plugin-api`.
+- 7c5f3b0: Update the `ServiceFactoryTester` to be able to test services that enables multi implementation installation.
+- Updated dependencies
+  - @backstage/backend-defaults@0.4.2-next.2
+  - @backstage/backend-plugin-api@0.8.0-next.2
+  - @backstage/backend-app-api@0.8.1-next.2
+  - @backstage/plugin-auth-node@0.5.0-next.2
+  - @backstage/plugin-events-node@0.3.9-next.2
+  - @backstage/config@1.2.0
+  - @backstage/errors@1.2.4
+  - @backstage/types@1.1.1
+
+## 0.4.5-next.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @backstage/backend-plugin-api@0.7.1-next.1
+  - @backstage/backend-app-api@0.8.1-next.1
+  - @backstage/backend-defaults@0.4.2-next.1
+  - @backstage/config@1.2.0
+  - @backstage/errors@1.2.4
+  - @backstage/types@1.1.1
+  - @backstage/plugin-auth-node@0.4.18-next.1
+  - @backstage/plugin-events-node@0.3.9-next.1
+
 ## 0.4.5-next.0
 
 ### Patch Changes

package/dist/index.cjs.js

@@ -1675,7 +1675,7 @@ function createPluginsForOrphanModules(features) {
   const pluginIds = /* @__PURE__ */ new Set();
   const modulePluginIds = /* @__PURE__ */ new Set();
   for (const feature of features) {
-    if (isInternalBackendFeature(feature)) {
+    if (isInternalBackendRegistrations(feature)) {
       const registrations = feature.getRegistrations();
       for (const registration of registrations) {
         if (registration.type === "plugin") {
@@ -1704,17 +1704,7 @@ function createExtensionPointTestModules(features, extensionPointTuples) {
     return [];
   }
   const registrations = features.flatMap((feature) => {
-    if (feature.$$type !== "@backstage/BackendFeature") {
-      throw new Error(
-        `Failed to add feature, invalid type '${feature.$$type}'`
-      );
-    }
-    if (isInternalBackendFeature(feature)) {
-      if (feature.version !== "v1") {
-        throw new Error(
-          `Failed to add feature, invalid version '${feature.version}'`
-        );
-      }
+    if (isInternalBackendRegistrations(feature)) {
       return feature.getRegistrations();
     }
     return [];
@@ -1883,8 +1873,24 @@ function registerTestHooks() {
   });
 }
 registerTestHooks();
-function isInternalBackendFeature(feature) {
-  return typeof feature.getRegistrations === "function";
+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 isInternalBackendRegistrations(feature) {
+  const internal = toInternalBackendFeature(feature);
+  if (internal.featureType === "registrations") {
+    return true;
+  }
+  return "getRegistrations" in internal;
 }
 
 class Node {
@@ -2084,7 +2090,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;
   }
@@ -2095,17 +2113,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;
@@ -2120,13 +2136,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);
   }
@@ -2138,6 +2157,9 @@ class ServiceRegistry {
       if (this.#providedFactories.get(ref.id)) {
         return false;
       }
+      if (ref.multiton) {
+        return false;
+      }
       return !ref.__defaultFactory;
     });
     if (missingDeps.length) {
@@ -2149,13 +2171,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) {
@@ -2171,21 +2193,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);
@@ -2197,72 +2226,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]);
   }
 }
 
@@ -2308,7 +2345,8 @@ class ServiceFactoryTester {
    */
   async getSubject(...args) {
     const [pluginId] = args;
-    return this.#registry.get(this.#subject, pluginId ?? "test");
+    const instance = this.#registry.get(this.#subject, pluginId ?? "test");
+    return instance;
   }
   /**
    * Return the service instance for any of the provided dependencies or built-in services.