ditox 3.2.0 → 3.3.1

package/src/removal-compatibility.test.ts

@@ -0,0 +1,259 @@
+import { describe, expect, it, vi } from 'vitest';
+import { bindModule, createContainer, declareModule, token } from './index';
+
+describe('3.x removal compatibility', () => {
+  it('retains a single binding after its callback throws and allows retry', () => {
+    const container = createContainer();
+    const resource = token();
+    const value = {};
+    const failure = new Error('failure');
+    const onRemoved = vi.fn().mockImplementationOnce(() => {
+      throw failure;
+    });
+    container.bindFactory(resource, () => value, { onRemoved });
+    container.resolve(resource);
+
+    expect(() => container.remove(resource)).toThrow(failure);
+    expect(container.resolve(resource)).toBe(value);
+    container.remove(resource);
+    expect(container.hasToken(resource)).toBe(false);
+    expect(onRemoved).toHaveBeenCalledTimes(2);
+  });
+
+  it('retains a module and its exports after a single removal fails', () => {
+    const container = createContainer();
+    const exported = token<number>();
+    const failure = new Error('destroy failed');
+    const destroy = vi.fn().mockImplementationOnce(() => {
+      throw failure;
+    });
+    const module = declareModule({
+      factory: () => ({ value: 42, destroy }),
+      exports: { value: exported },
+    });
+    bindModule(container, module);
+    expect(container.resolve(exported)).toBe(42);
+    expect(() => container.remove(module.token)).toThrow(failure);
+    expect(container.hasToken(module.token)).toBe(true);
+    expect(container.resolve(exported)).toBe(42);
+    container.remove(module.token);
+    expect(container.hasToken(module.token)).toBe(false);
+    expect(container.hasToken(exported)).toBe(false);
+    expect(destroy).toHaveBeenCalledTimes(2);
+  });
+
+  it('keeps legacy removal of replacements made by a single callback', () => {
+    const container = createContainer();
+    const resource = token();
+    const replacementFactory = vi.fn(() => 2);
+    container.bindFactory(resource, () => 1, {
+      onRemoved() {
+        container.bindFactory(resource, replacementFactory);
+        container.bindValue(resource, 2);
+      },
+    });
+    container.resolve(resource);
+    container.remove(resource);
+    expect(container.hasToken(resource)).toBe(false);
+    expect(replacementFactory).not.toHaveBeenCalled();
+  });
+
+  it('keeps live traversal when callbacks remove and append other bindings', () => {
+    const container = createContainer();
+    const first = token();
+    const second = token();
+    const appended = token();
+    const calls: string[] = [];
+    container.bindFactory(first, () => 1, {
+      onRemoved() {
+        calls.push('first');
+        container.remove(second);
+        container.bindFactory(appended, () => 3, {
+          onRemoved: () => {
+            calls.push('appended');
+          },
+        });
+        container.resolve(appended);
+      },
+    });
+    container.bindFactory(second, () => 2, {
+      onRemoved: () => {
+        calls.push('second');
+      },
+    });
+    container.resolve(first);
+    container.resolve(second);
+    container.removeAll();
+    expect(calls).toEqual(['first', 'second', 'appended']);
+    [first, second, appended].forEach((resource) =>
+      expect(container.hasToken(resource)).toBe(false),
+    );
+  });
+
+  it('keeps bounded nested bulk cleanup active rather than making it a no-op', () => {
+    const container = createContainer();
+    const first = token();
+    const second = token();
+    const calls: string[] = [];
+    let nested = false;
+    container.bindFactory(first, () => 1, {
+      onRemoved() {
+        calls.push('first');
+        if (!nested) {
+          nested = true;
+          container.removeAll();
+          expect(container.hasToken(second)).toBe(false);
+          calls.push('returned');
+        }
+      },
+    });
+    container.bindFactory(second, () => 2, {
+      onRemoved: () => {
+        calls.push('second');
+      },
+    });
+    container.resolve(first);
+    container.resolve(second);
+    container.removeAll();
+    expect(calls).toEqual(['first', 'first', 'second', 'returned']);
+  });
+
+  it('visits a factory deleted and reinserted at an already visited key', () => {
+    const container = createContainer();
+    const first = token<number>();
+    const second = token();
+    const calls: number[] = [];
+    const onRemoved = (value: number) => {
+      calls.push(value);
+    };
+    container.bindFactory(first, () => 1, { onRemoved });
+    container.bindFactory(second, () => 2, {
+      onRemoved() {
+        container.remove(first);
+        container.bindFactory(first, () => 3, { onRemoved });
+        container.resolve(first);
+      },
+    });
+    container.resolve(first);
+    container.resolve(second);
+    container.removeAll();
+    expect(calls).toEqual([1, 1, 3]);
+    expect(container.hasToken(first)).toBe(false);
+  });
+
+  it('keeps bounded single-token reentry active', () => {
+    const container = createContainer();
+    const resource = token();
+    let calls = 0;
+    container.bindFactory(resource, () => 1, {
+      onRemoved() {
+        calls++;
+        if (calls === 1) container.remove(resource);
+      },
+    });
+    container.resolve(resource);
+    container.removeAll();
+    expect(calls).toBe(2);
+    expect(container.hasToken(resource)).toBe(false);
+  });
+
+  it('does not revisit replacements at already visited keys', () => {
+    const container = createContainer();
+    const first = token();
+    const second = token();
+    const onRemoved = vi.fn();
+    container.bindFactory(first, () => 1, { onRemoved });
+    container.bindFactory(second, () => 2, {
+      onRemoved() {
+        container.bindValue(first, 3);
+      },
+    });
+    container.resolve(first);
+    container.resolve(second);
+    container.removeAll();
+    expect(onRemoved).toHaveBeenCalledExactlyOnceWith(1);
+    expect(container.hasToken(first)).toBe(false);
+  });
+});
+
+describe('bulk cleanup failures with reentry and accessors', () => {
+  it('continues after a nested single removal throws, retaining its legacy retry', () => {
+    const container = createContainer();
+    const first = token();
+    const second = token();
+    const last = token();
+    const failure = new Error('nested failure');
+    const onRemoved = vi.fn(() => {
+      throw failure;
+    });
+    const lastCallback = vi.fn();
+    container.bindFactory(first, () => 1, {
+      onRemoved: () => container.remove(second),
+    });
+    container.bindFactory(second, () => 2, { onRemoved });
+    container.bindFactory(last, () => 3, { onRemoved: lastCallback });
+    [first, second, last].forEach((resource) => container.resolve(resource));
+    expect(() => container.removeAll()).toThrow(failure);
+    expect(onRemoved).toHaveBeenCalledTimes(2);
+    expect(lastCallback).toHaveBeenCalledTimes(1);
+    [first, second, last].forEach((resource) =>
+      expect(container.hasToken(resource)).toBe(false),
+    );
+  });
+
+  it('finishes nested bulk cleanup before propagating its first error', () => {
+    const container = createContainer();
+    const first = token();
+    const second = token();
+    const third = token();
+    let nested = false;
+    const failure = new Error('nested failure');
+    const onRemoved = vi.fn();
+    container.bindFactory(first, () => 1, {
+      onRemoved() {
+        if (!nested) {
+          nested = true;
+          container.removeAll();
+        }
+      },
+    });
+    container.bindFactory(second, () => 2, {
+      onRemoved() {
+        throw failure;
+      },
+    });
+    container.bindFactory(third, () => 3, { onRemoved });
+    [first, second, third].forEach((resource) => container.resolve(resource));
+    expect(() => container.removeAll()).toThrow(failure);
+    expect(onRemoved).toHaveBeenCalledTimes(1);
+    [first, second, third].forEach((resource) =>
+      expect(container.hasToken(resource)).toBe(false),
+    );
+    container.removeAll();
+  });
+
+  it('continues after an onRemoved accessor throws even for an unresolved factory', () => {
+    const container = createContainer();
+    const first = token();
+    const second = token();
+    const failure = new Error('accessor failed');
+    const factory = vi.fn();
+    const getter = vi.fn(() => {
+      throw failure;
+    });
+    const onRemoved = vi.fn();
+    container.bindFactory(first, factory, {
+      get onRemoved() {
+        return getter();
+      },
+    });
+    container.bindFactory(second, () => undefined, { onRemoved });
+    container.resolve(second);
+    expect(() => container.removeAll()).toThrow(failure);
+    expect(getter).toHaveBeenCalledTimes(1);
+    expect(factory).not.toHaveBeenCalled();
+    expect(onRemoved).toHaveBeenCalledExactlyOnceWith(undefined);
+    expect(container.hasToken(first)).toBe(false);
+    expect(container.hasToken(second)).toBe(false);
+  });
+});

package/src/removal.test.ts

@@ -0,0 +1,190 @@
+import { describe, expect, it, vi } from 'vitest';
+import { bindModule, createContainer, declareModule, token } from './index';
+
+describe('container teardown', () => {
+  it('finishes cleanup after an onRemoved failure and does not retry callbacks', () => {
+    const container = createContainer();
+    const failure = new Error('cleanup failed');
+    const calls: string[] = [];
+    const tokens = ['before', 'failure', 'after'].map((name) => {
+      const resource = token(name);
+      container.bindFactory(resource, () => ({}), {
+        onRemoved() {
+          calls.push(name);
+          if (name === 'failure') throw failure;
+        },
+      });
+      container.resolve(resource);
+      return resource;
+    });
+    const value = token();
+    const unresolved = token();
+    const factory = vi.fn();
+    const onRemoved = vi.fn();
+    container.bindValue(value, 42);
+    container.bindFactory(unresolved, factory, { onRemoved });
+
+    expect(() => container.removeAll()).toThrow(failure);
+    expect(calls).toEqual(['before', 'failure', 'after']);
+    for (const resource of [...tokens, value, unresolved]) {
+      expect(container.hasToken(resource)).toBe(false);
+    }
+    expect(factory).not.toHaveBeenCalled();
+    expect(onRemoved).not.toHaveBeenCalled();
+    expect(() => container.removeAll()).not.toThrow();
+    expect(calls).toEqual(['before', 'failure', 'after']);
+  });
+
+  it.each([
+    new Error('first'),
+    undefined,
+    null,
+    false,
+    0,
+    'failure',
+  ])('rethrows the first value unchanged after all callbacks, including %s', (failure) => {
+    const container = createContainer();
+    const callbacks = [failure, new Error('second')].map((error) => {
+      const resource = token();
+      const onRemoved = vi.fn(() => {
+        throw error;
+      });
+      container.bindFactory(resource, () => undefined, { onRemoved });
+      container.resolve(resource);
+      return onRemoved;
+    });
+    let threw = false;
+    try {
+      container.removeAll();
+    } catch (error) {
+      threw = true;
+      expect(error).toBe(failure);
+    }
+    expect(threw).toBe(true);
+    callbacks.forEach((callback) => expect(callback).toHaveBeenCalledTimes(1));
+    container.removeAll();
+    callbacks.forEach((callback) => expect(callback).toHaveBeenCalledTimes(1));
+  });
+
+  it.each([
+    'singleton',
+    'scoped',
+  ] as const)('only disposes locally cached %s values and leaves parent values intact', (scope) => {
+    const parent = createContainer();
+    const child = createContainer(parent);
+    const inherited = token();
+    const shared = token();
+    const owned = token();
+    const parentCallback = vi.fn();
+    const childCallback = vi.fn(() => {
+      throw new Error('child cleanup failed');
+    });
+    const inheritedFactory = vi.fn(() => ({}));
+    const sharedFactory = vi.fn(() => ({}));
+    parent.bindFactory(inherited, inheritedFactory, {
+      scope,
+      onRemoved: parentCallback,
+    });
+    parent.bindFactory(shared, sharedFactory, {
+      scope,
+      onRemoved: parentCallback,
+    });
+    child.bindFactory(shared, sharedFactory, {
+      scope,
+      onRemoved: childCallback,
+    });
+    child.bindFactory(owned, () => ({}), { scope, onRemoved: childCallback });
+    const inheritedValue = child.resolve(inherited);
+    const parentValue = parent.resolve(shared);
+    const childValue = child.resolve(shared);
+    child.resolve(owned);
+
+    expect(() => child.removeAll()).toThrow();
+    expect(childCallback).toHaveBeenCalledTimes(scope === 'scoped' ? 2 : 1);
+    if (scope === 'scoped') {
+      expect(childCallback).toHaveBeenCalledWith(childValue);
+      expect(childValue).not.toBe(parentValue);
+    } else {
+      expect(childValue).toBe(parentValue);
+    }
+    expect(parentCallback).not.toHaveBeenCalled();
+    expect(child.resolve(inherited)).toBe(inheritedValue);
+    expect(child.resolve(shared)).toBe(parentValue);
+    child.removeAll();
+    parent.removeAll();
+    expect(parentCallback).toHaveBeenCalledTimes(2);
+    expect(inheritedFactory).toHaveBeenCalledTimes(1);
+    expect(sharedFactory).toHaveBeenCalledTimes(scope === 'scoped' ? 2 : 1);
+  });
+
+  it('keeps resolved dependencies available during normal bulk callbacks', () => {
+    const container = createContainer();
+    const dependency = token();
+    const consumer = token();
+    const value = {};
+    const onRemoved = vi.fn();
+    container.bindFactory(dependency, () => value, { onRemoved });
+    container.bindFactory(consumer, () => ({}), {
+      onRemoved() {
+        expect(container.resolve(dependency)).toBe(value);
+      },
+    });
+    container.resolve(dependency);
+    container.resolve(consumer);
+    container.removeAll();
+    expect(onRemoved).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not resolve unused factories or dispose transient values', () => {
+    const container = createContainer();
+    const unused = token();
+    const transient = token();
+    const unusedFactory = vi.fn();
+    const unusedCallback = vi.fn();
+    const transientFactory = vi.fn(() => ({}));
+    const transientCallback = vi.fn();
+    container.bindFactory(unused, unusedFactory, { onRemoved: unusedCallback });
+    // JavaScript callers can pass extra options; transient still has no teardown.
+    const options = {
+      scope: 'transient' as const,
+      onRemoved: transientCallback,
+    };
+    container.bindFactory(transient, transientFactory, options);
+    expect(container.resolve(transient)).not.toBe(container.resolve(transient));
+
+    container.removeAll();
+    expect(unusedFactory).not.toHaveBeenCalled();
+    expect(unusedCallback).not.toHaveBeenCalled();
+    expect(transientFactory).toHaveBeenCalledTimes(2);
+    expect(transientCallback).not.toHaveBeenCalled();
+    expect(container.hasToken(transient)).toBe(false);
+  });
+
+  it('cleans module exports and subsequent modules after destroy throws', () => {
+    const container = createContainer();
+    const exported = token<number>();
+    const failure = new Error('module cleanup failed');
+    const failingModule = declareModule({
+      factory: () => ({
+        value: 42,
+        destroy: () => {
+          throw failure;
+        },
+      }),
+      exports: { value: exported },
+    });
+    const destroy = vi.fn();
+    const healthyModule = declareModule({ factory: () => ({ destroy }) });
+    bindModule(container, failingModule);
+    bindModule(container, healthyModule);
+    expect(container.resolve(exported)).toBe(42);
+    container.resolve(healthyModule.token);
+
+    expect(() => container.removeAll()).toThrow(failure);
+    expect(container.hasToken(exported)).toBe(false);
+    expect(container.hasToken(failingModule.token)).toBe(false);
+    expect(container.hasToken(healthyModule.token)).toBe(false);
+    container.removeAll();
+    expect(destroy).toHaveBeenCalledTimes(1);
+  });
+});

package/src/tokens.test.ts

@@ -1,10 +1,11 @@
-import {optional, token} from './tokens';
+import { describe, expect, it } from 'vitest';
+import { optional, token } from './tokens';
 
 describe('token()', () => {
   it('should return a token with description it is specified', () => {
     expect(token().symbol.description).toBeUndefined();
     expect(token('text1').symbol.description).toBe('text1');
-    expect(token({description: 'text2'}).symbol.description).toBe('text2');
+    expect(token({ description: 'text2' }).symbol.description).toBe('text2');
   });
 
   it('should return independent tokens if key is not specified', () => {
@@ -17,9 +18,9 @@ describe('token()', () => {
   });
 
   it('should return tokens with the same symbol if key is specified', () => {
-    const source = token({key: 'test-token'});
-    const clone = token({key: 'test-token'});
-    const something = token({key: 'something-else'});
+    const source = token({ key: 'test-token' });
+    const clone = token({ key: 'test-token' });
+    const something = token({ key: 'something-else' });
 
     expect(source).not.toBe(clone);
     expect(source.symbol).toBe(clone.symbol);
@@ -44,9 +45,9 @@ describe('optional()', () => {
     expect(o2.optionalValue).toBe(-1);
   });
 
-  it('should reuse symbol from a source token ifits key is specified', () => {
-    const source = token({key: 'token-key'});
-    const clone = token({key: 'token-key'});
+  it('should reuse symbol from a source token if its key is specified', () => {
+    const source = token({ key: 'token-key' });
+    const clone = token({ key: 'token-key' });
     const optClone = optional(clone);
 
     expect(optClone.symbol).toBe(source.symbol);

package/src/tokens.ts

@@ -56,13 +56,13 @@ export function token<T>(description?: string): Token<T>;
  */ export function token<T>(options?: TokenOptions): Token<T>;
 export function token<T>(options?: TokenOptions | string): Token<T> {
   const normalized: TokenOptions | undefined =
-    typeof options === 'string' ? {description: options} : options;
+    typeof options === 'string' ? { description: options } : options;
 
   const symbol: symbol = normalized?.key
     ? Symbol.for(normalized.key)
     : Symbol(normalized?.description);
 
-  return {symbol};
+  return { symbol };
 }
 
 /**

package/src/utils.test.ts

@@ -1,4 +1,6 @@
-import {createContainer, ResolverError} from './container';
+import { describe, expect, it } from 'vitest';
+import { createContainer, ResolverError } from './container';
+import { optional, token } from './tokens';
 import {
   bindMultiValue,
   injectable,
@@ -8,7 +10,6 @@ import {
   tryResolveValue,
   tryResolveValues,
 } from './utils';
-import {optional, token} from './tokens';
 
 const NUMBER = token<number>('number');
 const STRING = token<string>('string');
@@ -60,19 +61,19 @@ describe('tryResolveValue()', () => {
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, 'abc');
 
-    const props: {a: number; b: string} = tryResolveValue(container, {
+    const props: { a: number; b: string } = tryResolveValue(container, {
       a: NUMBER,
       b: STRING,
     });
-    expect(props).toEqual({a: 1, b: 'abc'});
+    expect(props).toEqual({ a: 1, b: 'abc' });
   });
 
   it('should return "undefined" item in case a value is not provided', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const props = tryResolveValue(container, {a: NUMBER, b: STRING});
-    expect(props).toEqual({a: 1, b: undefined});
+    const props = tryResolveValue(container, { a: NUMBER, b: STRING });
+    expect(props).toEqual({ a: 1, b: undefined });
   });
 
   it('should return values of optional tokens in case they are not provided', () => {
@@ -86,7 +87,7 @@ describe('tryResolveValue()', () => {
       b: STRING,
       c: OPTIONAL_STRING,
     });
-    expect(props).toEqual({a: 1, b: undefined, c: 'value'});
+    expect(props).toEqual({ a: 1, b: undefined, c: 'value' });
   });
 });
 
@@ -149,11 +150,11 @@ describe('resolveValue()', () => {
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, 'abc');
 
-    const props: {a: number; b: string} = resolveValue(container, {
+    const props: { a: number; b: string } = resolveValue(container, {
       a: NUMBER,
       b: STRING,
     });
-    expect(props).toEqual({a: 1, b: 'abc'});
+    expect(props).toEqual({ a: 1, b: 'abc' });
   });
 
   it('should throw an error in case a value is not provided', () => {
@@ -161,7 +162,7 @@ describe('resolveValue()', () => {
     container.bindValue(NUMBER, 1);
 
     expect(() => {
-      resolveValue(container, {a: NUMBER, b: STRING});
+      resolveValue(container, { a: NUMBER, b: STRING });
     }).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
     );
@@ -175,7 +176,7 @@ describe('resolveValue()', () => {
       a: NUMBER,
       b: optional(STRING, 'value'),
     });
-    expect(props).toEqual({a: 1, b: 'value'});
+    expect(props).toEqual({ a: 1, b: 'value' });
   });
 });
 
@@ -224,7 +225,7 @@ describe('resolveValues()', () => {
 });
 
 describe('injectable()', () => {
-  function join({a, b}: {a: number; b: string}): string {
+  function join({ a, b }: { a: number; b: string }): string {
     return `${a}/${b}`;
   }
 
@@ -275,7 +276,7 @@ describe('injectable()', () => {
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, '2');
 
-    const decoratedFactory = injectable(join, {a: NUMBER, b: STRING});
+    const decoratedFactory = injectable(join, { a: NUMBER, b: STRING });
 
     expect(decoratedFactory(container)).toBe('1/2');
   });
@@ -284,7 +285,7 @@ describe('injectable()', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const decoratedFactory = injectable(join, {a: NUMBER, b: STRING});
+    const decoratedFactory = injectable(join, { a: NUMBER, b: STRING });
 
     expect(() => decoratedFactory(container)).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),
@@ -359,7 +360,7 @@ describe('injectableClass()', () => {
     a: number;
     b: string;
 
-    constructor(props: {a: number; b: string}) {
+    constructor(props: { a: number; b: string }) {
       this.a = props.a;
       this.b = props.b;
     }
@@ -374,7 +375,7 @@ describe('injectableClass()', () => {
     container.bindValue(NUMBER, 1);
     container.bindValue(STRING, '2');
 
-    const factory = injectableClass(TestClass, {a: NUMBER, b: STRING});
+    const factory = injectableClass(TestClass, { a: NUMBER, b: STRING });
 
     expect(factory(container).join()).toBe('1/2');
   });
@@ -383,7 +384,7 @@ describe('injectableClass()', () => {
     const container = createContainer();
     container.bindValue(NUMBER, 1);
 
-    const factory = injectableClass(TestClass, {a: NUMBER, b: STRING});
+    const factory = injectableClass(TestClass, { a: NUMBER, b: STRING });
 
     expect(() => factory(container)).toThrowError(
       new ResolverError(`Token "${STRING.symbol.description}" is not provided`),