feat: Implement checking for if "alias-has-registrations"

This permits eg. creation of specialized test utils where default stubs are
registered but only if no other matching registrations are present.

packages/injectable/core/index.d.ts

@@ -14,19 +14,21 @@ export type Override = <
 export interface DiContainer extends DiContainerForInjection {
   purge: (injectableKey: Injectable<any, any, any>) => void;
 
+  preventSideEffects: () => void;
   permitSideEffects: (
     injectableKey: InjectionToken<any, any> | Injectable<any, any, any>,
   ) => void;
 
   override: Override;
   earlyOverride: Override;
-
   unoverride(alias: InjectionToken<any, any> | Injectable<any, any, any>): void;
 
   register(...injectables: Injectable<any, any, any>[]): void;
-
   deregister(...injectables: Injectable<any, any, any>[]): void;
-  preventSideEffects: () => void;
+
+  hasRegistrations: (
+    alias: InjectionToken<any, any> | Injectable<any, any, any>,
+  ) => boolean;
 }
 
 export type Instantiate<InjectionInstance, InstantiationParam> = {

packages/injectable/core/index.test-d.ts

@@ -544,3 +544,9 @@ expectType<{ someInjectable: Injectable<string, unknown, number> }>(
 );
 
 expectType<{ keys: [1, 2, 3] }>(getKeyedSingletonCompositeKey(1, 2, 3));
+
+// given injectable, typing for "alias has registrations" is ok
+expectType<boolean>(di.hasRegistrations(someInjectable));
+
+// given token, typing for "alias has registrations" is ok
+expectType<boolean>(di.hasRegistrations(someInjectionToken));

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

@@ -272,6 +272,8 @@ export default (containerId, { detectCycles = true } = {}) => {
       getRelatedInjectables(alias).flatMap(injectable => [
         ...instancesByInjectableMap.get(injectable).values(),
       ]),
+
+    hasRegistrations: alias => !!getRelatedInjectables(alias).length,
   };
 
   return publicDi;

packages/injectable/core/src/scenarios/alias-has-registrations.test.js

@@ -0,0 +1,91 @@
+import getInjectable from '../getInjectable/getInjectable';
+import createContainer from '../dependency-injection-container/createContainer';
+import getInjectionToken from '../getInjectionToken/getInjectionToken';
+
+describe('alias-has-registrations', () => {
+  let di;
+
+  beforeEach(() => {
+    di = createContainer('irrelevant');
+  });
+
+  describe('given an injectable with or without an injection token', () => {
+    let someInjectable;
+    let someInjectionToken;
+
+    beforeEach(() => {
+      someInjectionToken = getInjectionToken({
+        id: 'some-injection-token',
+      });
+
+      someInjectable = getInjectable({
+        id: 'some-injectable',
+        instantiate: () => 'irrelevant',
+        injectionToken: someInjectionToken,
+      });
+    });
+
+    it('given registered, when checking if the token has registrations, it does', () => {
+      di.register(someInjectable);
+
+      const tokenHasRegistrations = di.hasRegistrations(someInjectionToken);
+
+      expect(tokenHasRegistrations).toBe(true);
+    });
+
+    it('but not registered, when checking if the token has registrations, it does not', () => {
+      // Note: no registration.
+      // di.register(someInjectable);
+
+      const injectableHasRegistrations =
+        di.hasRegistrations(someInjectionToken);
+
+      expect(injectableHasRegistrations).toBe(false);
+    });
+
+    it('given registered, when checking if the injectable has registrations, it does', () => {
+      di.register(someInjectable);
+
+      const injectableHasRegistrations = di.hasRegistrations(someInjectable);
+
+      expect(injectableHasRegistrations).toBe(true);
+    });
+
+    it('but not registered, when checking if the injectable has registrations, it does not', () => {
+      // Note: no registration.
+      // di.register(someInjectable);
+
+      const injectableHasRegistrations = di.hasRegistrations(someInjectable);
+
+      expect(injectableHasRegistrations).toBe(false);
+    });
+
+    it('given registered, but deregistered, when checking if the token has registrations, it does not', () => {
+      di.register(someInjectable);
+      di.deregister(someInjectable);
+
+      const injectableHasRegistrations =
+        di.hasRegistrations(someInjectionToken);
+
+      expect(injectableHasRegistrations).toBe(false);
+    });
+
+    it('but not registered, when checking if the injectable has registrations, it does not', () => {
+      // Note: no registration.
+      // di.register(someInjectable);
+
+      const injectableHasRegistrations = di.hasRegistrations(someInjectable);
+
+      expect(injectableHasRegistrations).toBe(false);
+    });
+
+    it('given registered, but deregistered, when checking if the injectable has registrations, it does not', () => {
+      di.register(someInjectable);
+      di.deregister(someInjectable);
+
+      const injectableHasRegistrations = di.hasRegistrations(someInjectable);
+
+      expect(injectableHasRegistrations).toBe(false);
+    });
+  });
+});