rework logic to explicitly rely on the list of plugins to create the map keys

Signed-off-by: aramissennyeydd <aramis.sennyey@doordash.com>

packages/backend-app-api/src/wiring/BackendInitializer.test.ts

@@ -1129,6 +1129,44 @@ describe('BackendInitializer', () => {
     await backend.start();
   });
 
+  it('should ignore modules that do not have a matching plugin', async () => {
+    expect.assertions(1);
+    const backend = new BackendInitializer(baseFactories);
+    const instanceMetadataPlugin = createBackendPlugin({
+      pluginId: 'instance-metadata',
+      register(reg) {
+        reg.registerInit({
+          deps: {
+            instanceMetadata: coreServices.rootInstanceMetadata,
+          },
+          async init({ instanceMetadata }) {
+            await expect(
+              instanceMetadata.getInstalledPlugins(),
+            ).resolves.toEqual([
+              {
+                pluginId: 'instance-metadata',
+                modules: [],
+              },
+            ]);
+          },
+        });
+      },
+    });
+    const module = createBackendModule({
+      pluginId: 'test',
+      moduleId: 'test',
+      register(reg) {
+        reg.registerInit({
+          deps: {},
+          async init() {},
+        });
+      },
+    });
+    backend.add(module);
+    backend.add(instanceMetadataPlugin);
+    await backend.start();
+  });
+
   it('should prevent writes to the instance metadata service', async () => {
     expect.assertions(1);
     const backend = new BackendInitializer(baseFactories);

packages/backend-app-api/src/wiring/BackendInitializer.ts

@@ -99,38 +99,38 @@ const instanceRegistry = new (class InstanceRegistry {
 })();
 
 function createRootInstanceMetadataServiceFactory(
-  registrations: InternalBackendRegistrations[],
+  rawRegistrations: InternalBackendRegistrations[],
 ) {
   const installedPlugins: Map<string, RootInstanceMetadataServicePluginInfo> =
     new Map();
-  for (const registration of registrations) {
-    if (registration.featureType === 'registrations') {
-      for (const feature of registration.getRegistrations()) {
-        if (feature.type === 'plugin') {
-          if (!installedPlugins.get(feature.pluginId)) {
-            installedPlugins.set(feature.pluginId, {
-              pluginId: feature.pluginId,
-              modules: [],
-            });
-          }
-        } else if (feature.type === 'module') {
-          if (!installedPlugins.get(feature.pluginId)) {
-            installedPlugins.set(feature.pluginId, {
-              pluginId: feature.pluginId,
-              modules: [],
-            });
-          }
-          (
-            installedPlugins.get(feature.pluginId)!.modules as Array<{
-              moduleId: string;
-            }>
-          ).push({
-            moduleId: feature.moduleId,
-          });
-        }
-      }
+  const registrations = rawRegistrations
+    .filter(registration => registration.featureType === 'registrations')
+    .flatMap(registration => registration.getRegistrations());
+  const plugins = registrations.filter(
+    registration => registration.type === 'plugin',
+  );
+  const modules = registrations.filter(
+    registration => registration.type === 'module',
+  );
+  for (const plugin of plugins) {
+    const { pluginId } = plugin;
+    if (!installedPlugins.get(pluginId)) {
+      installedPlugins.set(pluginId, {
+        pluginId,
+        modules: [],
+      });
     }
   }
+  for (const module of modules) {
+    const { pluginId, moduleId } = module;
+    const installedPlugin = installedPlugins.get(pluginId);
+    if (installedPlugin) {
+      (installedPlugin.modules as Array<{ moduleId: string }>).push({
+        moduleId,
+      });
+    }
+  }
+
   return createServiceFactory({
     service: coreServices.rootInstanceMetadata,
     deps: {},