Update container with unbind all

.changeset/dull-books-cover.md

@@ -0,0 +1,5 @@
+---
+"@inversifyjs/core": minor
+---
+
+Updated `BindingService` with `getNonParentBoundServices`

.changeset/fluffy-ravens-heal.md

@@ -0,0 +1,5 @@
+---
+"@inversifyjs/container": minor
+---
+
+Updated `Container` with `unbindAll`

packages/container/libraries/container/src/container/services/Container.spec.ts

@@ -59,6 +59,7 @@ describe(Container.name, () => {
     bindingServiceMock = {
       clone: jest.fn(),
       get: jest.fn(),
+      getNonParentBoundServices: jest.fn(),
       removeAllByModuleId: jest.fn(),
       removeAllByServiceId: jest.fn(),
       set: jest.fn(),
@@ -1153,6 +1154,75 @@ describe(Container.name, () => {
     });
   });
 
+  describe('.unbindAll', () => {
+    describe('when called', () => {
+      let serviceIdsFixture: string[];
+      let result: unknown;
+
+      beforeAll(async () => {
+        serviceIdsFixture = ['service1', 'service2'];
+        bindingServiceMock.getNonParentBoundServices.mockReturnValueOnce(
+          serviceIdsFixture,
+        );
+
+        result = await new Container().unbindAll();
+      });
+
+      afterAll(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should call resolveServiceDeactivations for each service', () => {
+        expect(resolveServiceDeactivations).toHaveBeenCalledTimes(
+          serviceIdsFixture.length,
+        );
+        for (const serviceId of serviceIdsFixture) {
+          expect(resolveServiceDeactivations).toHaveBeenCalledWith(
+            expect.any(Object),
+            serviceId,
+          );
+        }
+      });
+
+      it('should call removeAllByServiceId on activationService for each service', () => {
+        expect(
+          activationServiceMock.removeAllByServiceId,
+        ).toHaveBeenCalledTimes(serviceIdsFixture.length);
+        for (const serviceId of serviceIdsFixture) {
+          expect(
+            activationServiceMock.removeAllByServiceId,
+          ).toHaveBeenCalledWith(serviceId);
+        }
+      });
+
+      it('should call removeAllByServiceId on bindingService for each service', () => {
+        expect(bindingServiceMock.removeAllByServiceId).toHaveBeenCalledTimes(
+          serviceIdsFixture.length,
+        );
+        for (const serviceId of serviceIdsFixture) {
+          expect(bindingServiceMock.removeAllByServiceId).toHaveBeenCalledWith(
+            serviceId,
+          );
+        }
+      });
+
+      it('should call removeAllByServiceId on deactivationService for each service', () => {
+        expect(
+          deactivationServiceMock.removeAllByServiceId,
+        ).toHaveBeenCalledTimes(serviceIdsFixture.length);
+        for (const serviceId of serviceIdsFixture) {
+          expect(
+            deactivationServiceMock.removeAllByServiceId,
+          ).toHaveBeenCalledWith(serviceId);
+        }
+      });
+
+      it('should return undefined', () => {
+        expect(result).toBeUndefined();
+      });
+    });
+  });
+
   describe('.unload', () => {
     let containerModuleFixture: ContainerModule;
 

packages/container/libraries/container/src/container/services/Container.ts

@@ -270,6 +270,36 @@ export class Container {
     this.#deactivationService.removeAllByServiceId(serviceIdentifier);
   }
 
+  public async unbindAll(): Promise<void> {
+    const deactivationParams: DeactivationParams =
+      this.#buildDeactivationParams();
+
+    const nonParentBoundServiceIds: ServiceIdentifier[] = [
+      ...this.#bindingService.getNonParentBoundServices(),
+    ];
+
+    await Promise.all(
+      nonParentBoundServiceIds.map(
+        async (serviceId: ServiceIdentifier): Promise<void> =>
+          resolveServiceDeactivations(deactivationParams, serviceId),
+      ),
+    );
+
+    /*
+     * Removing service related objects here so unload is deterministic.
+     *
+     * Removing service related objects as soon as resolveModuleDeactivations takes
+     * effect leads to module deactivations not triggering previously deleted
+     * deactivations, introducing non determinism depending in the order in which
+     * services are deactivated.
+     */
+    for (const serviceId of nonParentBoundServiceIds) {
+      this.#activationService.removeAllByServiceId(serviceId);
+      this.#bindingService.removeAllByServiceId(serviceId);
+      this.#deactivationService.removeAllByServiceId(serviceId);
+    }
+  }
+
   public async unload(...modules: ContainerModule[]): Promise<void> {
     const deactivationParams: DeactivationParams =
       this.#buildDeactivationParams();

packages/container/libraries/core/src/binding/services/BindingService.spec.ts

@@ -209,6 +209,35 @@ describe(BindingService.name, () => {
     });
   });
 
+  describe('.getNonParentBoundServices', () => {
+    describe('when called', () => {
+      let serviceIdsFixture: ServiceIdentifier[];
+
+      let result: Iterable<ServiceIdentifier>;
+
+      beforeAll(() => {
+        serviceIdsFixture = ['service-id-1', 'service-id-2'];
+
+        bindingMapsMock.getAllKeys.mockReturnValueOnce(serviceIdsFixture);
+
+        result = bindingService.getNonParentBoundServices();
+      });
+
+      afterAll(() => {
+        jest.clearAllMocks();
+      });
+
+      it('should return the non-parent bound services', () => {
+        expect(result).toStrictEqual(serviceIdsFixture);
+      });
+
+      it('should call bindingMaps.getAllKeys()', () => {
+        expect(bindingMapsMock.getAllKeys).toHaveBeenCalledTimes(1);
+        expect(bindingMapsMock.getAllKeys).toHaveBeenCalledWith('serviceId');
+      });
+    });
+  });
+
   describe('.removeAllByModuleId', () => {
     let moduleIdFixture: number;
 

packages/container/libraries/core/src/binding/services/BindingService.ts

@@ -61,6 +61,10 @@ export class BindingService implements Cloneable<BindingService> {
     );
   }
 
+  public getNonParentBoundServices(): Iterable<ServiceIdentifier> {
+    return this.#bindingMaps.getAllKeys(BindingRelationKind.serviceId);
+  }
+
   public getByModuleId<TResolved>(
     moduleId: number,
   ): Iterable<Binding<TResolved>> | undefined {

packages/container/libraries/core/src/common/models/OneToManyMapStar.spec.ts

@@ -127,6 +127,46 @@ describe(OneToManyMapStar.name, () => {
     });
   });
 
+  describe('.getAllKeys', () => {
+    describe('having a OneToManyMapStart with a single model', () => {
+      let modelFixture: unknown;
+      let relationFixture: Required<RelationTest>;
+      let relationKeyFixture: RelationKey.foo;
+      let oneToManyMapStar: OneToManyMapStar<unknown, RelationTest>;
+
+      beforeAll(() => {
+        modelFixture = Symbol();
+        relationFixture = {
+          bar: 3,
+          foo: 'foo',
+        };
+        relationKeyFixture = RelationKey.foo;
+        oneToManyMapStar = new OneToManyMapStar<unknown, RelationTest>({
+          bar: {
+            isOptional: true,
+          },
+          foo: {
+            isOptional: false,
+          },
+        });
+
+        oneToManyMapStar.set(modelFixture, relationFixture);
+      });
+
+      describe('when called', () => {
+        let result: unknown;
+
+        beforeAll(() => {
+          result = [...oneToManyMapStar.getAllKeys(relationKeyFixture)];
+        });
+
+        it('should return expected result', () => {
+          expect(result).toStrictEqual([relationFixture[relationKeyFixture]]);
+        });
+      });
+    });
+  });
+
   describe('.removeByRelation', () => {
     describe('having a OneToManyMapStart with a no models', () => {
       let relationFixture: Required<RelationTest>;

packages/container/libraries/core/src/common/models/OneToManyMapStar.ts

@@ -63,6 +63,12 @@ export class OneToManyMapStar<TModel, TRelation extends object>
     return this.#relationToModelsMaps[key].get(value)?.values();
   }
 
+  public getAllKeys<TKey extends keyof TRelation>(
+    key: TKey,
+  ): Iterable<TRelation[TKey]> {
+    return this.#relationToModelsMaps[key].keys();
+  }
+
   public removeByRelation<TKey extends keyof TRelation>(
     key: TKey,
     value: Required<TRelation>[TKey],

packages/container/libraries/core/src/common/models/__mocks__/OneToManyMapStar.ts

@@ -5,6 +5,8 @@ const cloneMock: jest.Mock<any> = jest.fn();
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const getMock: jest.Mock<any> = jest.fn();
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
+const getAllKeysMock: jest.Mock<any> = jest.fn();
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const removeByRelationMock: jest.Mock<any> = jest.fn();
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const setMock: jest.Mock<any> = jest.fn();
@@ -16,6 +18,10 @@ export class OneToManyMapStar<TModel, TRelation extends object> {
     value: Required<TRelation>[TKey],
   ) => Iterable<TModel> | undefined;
 
+  public readonly getAllKeys: <TKey extends keyof TRelation>(
+    key: TKey,
+  ) => Iterable<TRelation[TKey]>;
+
   public readonly removeByRelation: <TKey extends keyof TRelation>(
     key: TKey,
     value: Required<TRelation>[TKey],
@@ -26,6 +32,7 @@ export class OneToManyMapStar<TModel, TRelation extends object> {
   constructor() {
     this.clone = cloneMock;
     this.get = getMock;
+    this.getAllKeys = getAllKeysMock;
     this.removeByRelation = removeByRelationMock;
     this.set = setMock;
   }