feat!: Make the injectable id for "meta" namespaced to avoid collisions

BREAKING CHANGE: Make sure previous usages of injectable id of meta do not break with the
new addition of namespace. Eg. what previously was di.injectManyWithMeta(someInjectionToken) ->
{ id: 'some-id', instance: ... }
...will now become:
{ id: 'some-scope:some-id', instance: ... }
...when a scope is present.

packages/injectable/core/src/dependency-injection-container/createContainer.js

@@ -49,6 +49,7 @@ export default (containerId, { detectCycles = true } = {}) => {
       getRelatedInjectables,
       getInject: () => decoratedPrivateInject,
       setDependee,
+      getNamespacedId,
     });
 
   const nonDecoratedPrivateInjectMany =

packages/injectable/core/src/dependency-injection-container/privateInjectManyFor.js

@@ -6,6 +6,7 @@ export const privateInjectManyFor =
     getRelatedInjectables,
     getInject,
     setDependee,
+    getNamespacedId,
   }) =>
   ({ withMeta }) =>
   (
@@ -34,16 +35,18 @@ export const privateInjectManyFor =
         return instance;
       }
 
+      const namespacedId = getNamespacedId(injectable);
+
       if (!isPromise(instance)) {
         return {
           instance,
-          meta: { id: injectable.id },
+          meta: { id: namespacedId },
         };
       }
 
       return instance.then(awaitedInstance => ({
         instance: awaitedInstance,
-        meta: { id: injectable.id },
+        meta: { id: namespacedId },
       }));
     });
 

packages/injectable/core/src/scenarios/injection-with-meta-data.test.js

@@ -29,6 +29,84 @@ describe('injection with meta data', () => {
     ]);
   });
 
+  it('given scope, when injecting many sync injectable with meta data, does so', () => {
+    const someInjectionToken = getInjectionToken({
+      id: 'some-injection-token-id',
+    });
+
+    const registerInScopeInjectable = getInjectable({
+      id: 'some-scope',
+
+      instantiate: di => injectable => {
+        di.register(injectable);
+      },
+
+      scope: true,
+    });
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: () => 'some-instance',
+      injectionToken: someInjectionToken,
+    });
+
+    const di = createContainer('irrelevant');
+
+    di.register(registerInScopeInjectable);
+
+    const registerInScope = di.inject(registerInScopeInjectable);
+
+    registerInScope(someInjectable);
+
+    const actual = di.injectManyWithMeta(someInjectionToken);
+
+    expect(actual).toEqual([
+      {
+        instance: 'some-instance',
+        meta: { id: 'some-scope:some-injectable' },
+      },
+    ]);
+  });
+
+  it('given scope, when injecting many async injectable with meta data, does so', async () => {
+    const someInjectionToken = getInjectionToken({
+      id: 'some-injection-token-id',
+    });
+
+    const registerInScopeInjectable = getInjectable({
+      id: 'some-scope',
+
+      instantiate: di => injectable => {
+        di.register(injectable);
+      },
+
+      scope: true,
+    });
+
+    const someInjectable = getInjectable({
+      id: 'some-injectable',
+      instantiate: async () => 'some-instance',
+      injectionToken: someInjectionToken,
+    });
+
+    const di = createContainer('irrelevant');
+
+    di.register(registerInScopeInjectable);
+
+    const registerInScope = di.inject(registerInScopeInjectable);
+
+    registerInScope(someInjectable);
+
+    const actual = await di.injectManyWithMeta(someInjectionToken);
+
+    expect(actual).toEqual([
+      {
+        instance: 'some-instance',
+        meta: { id: 'some-scope:some-injectable' },
+      },
+    ]);
+  });
+
   it('given injecting many async injectable with meta data, does so', async () => {
     const someInjectionToken = getInjectionToken({
       id: 'some-injection-token-id',