Feature Request: Ability To Unbind @named Target

[dac514]

Hi,

I am using the @inject syntax to do IoC. It's working as expected.

For unit tests I needed the ability to override the binding so that I could hotswap my class with a mock. Someone in #143 suggested a clever way to this:

kernel.unbind("HttpConfig")
kernel.bind("HttpConfig").to(customHttpConfig)

However, my issue is that the object I want to override is declared using this syntax:

kernel.bind<ActiveDirectory>('Helper').to(ActiveDirectory).inSingletonScope().whenTargetNamed('ActiveDirectory');

Currently the only way I can override is:

    kernel.unbind('Helper');
    kernel.bind<ActiveDirectory>('Helper').to(MockActiveDirectory).inSingletonScope().whenTargetNamed('ActiveDirectory');

The problem with this approach is that I am only interested in overriding the 'ActiveDirectory' class and not all Helpers.

Help?

[acopalipsis]

if I understand correctly, then I do it -

// app-configuration.ts

export const app: Container = new Container();

app.bind<ISomeConfig>( Symbol.for( 'SomeConfig' ) ).to( { name: "APP_NAME" } );

// .spec.ts

import { app } from "../src/app-configuration.ts";

let spec: Container = new Container();
spec.parent = app;
spec.bind<ISomeConfig>( Symbol.for( 'SomeConfig' ) ).to( { name: "SPEC_NAME" } );

console.log( spec.get<ISomeConfig>( Symbol.for( 'SomeConfig' ) ).name ); // SPEC_NAME

[remojansen]

Thanks for the prosal 👍 @acopalipsis solution is a good workaround. There are two workarounds at the moment:

• Use one kernel for test and one kernel for app
• Use kernel modules (kernel modules can load and unload groups of bindings)

Anyway this feature will be implemented in the future. It is likely to be released in the upcoming 3.1 release.

[tonyhallett]

Here is a solution, although it has not been carefully considered but works for your example

rebindContainer.ts

import {Container, interfaces, METADATA_KEY, BindingTypeEnum} from 'inversify'
import { getBindingDictionary} from 'inversify/dts/planning/planner'
const plannerExports=require('inversify/lib/planning/planner.js')
const gbd:typeof getBindingDictionary=plannerExports.getBindingDictionary;
type ServiceIdentifierOrArray=interfaces.ServiceIdentifier<any>|interfaces.ServiceIdentifier<any>[]
export class RebindContainer extends Container{
    private bd:interfaces.Lookup<interfaces.Binding<any>>
    constructor(options?:interfaces.ContainerOptions){
        super(options);
        this.bd=gbd(this);
    }
    private bindingMatchesTarget(binding:interfaces.Binding<any>,key:string | number | symbol,value:string){
        let found=false;
        if(binding.constraint&&binding.constraint.metaData){
            if(binding.constraint.metaData.key===key&&binding.constraint.metaData.value===value){
                found=true;
            }
        }
        return found;
    }
    private replaceBindingValue(binding:interfaces.Binding<any>,newValue:any){
        let clearCache=true;
        switch(binding.type){
            case BindingTypeEnum.ConstantValue:
                binding.cache=newValue;
                clearCache=false;
                break;
            case BindingTypeEnum.Constructor:
                binding.implementationType=newValue;
                break;
            case BindingTypeEnum.DynamicValue:
                binding.dynamicValue=newValue;
                break;
            case BindingTypeEnum.Factory:
                binding.factory=newValue;
                break;
            case BindingTypeEnum.Function:
                binding.cache=newValue;
                clearCache=false;
                break;
            case BindingTypeEnum.Instance:
                binding.implementationType=newValue;
                break;
            case BindingTypeEnum.Provider:
                binding.provider=newValue;
        }
        if(clearCache) binding.cache=undefined;
        binding.activated=false;
    }
    private getSidMatcher(serviceIdentifier?:ServiceIdentifierOrArray):(sid:interfaces.ServiceIdentifier<any>)=>boolean{
        let matchesSid=(sid:interfaces.ServiceIdentifier<any>)=>true;
        if(serviceIdentifier){
            let serviceIdentifiers:interfaces.ServiceIdentifier<any>[]=[];
            if(!Array.isArray(serviceIdentifier)){
                serviceIdentifiers.push(serviceIdentifier)
            }else{
                serviceIdentifiers=serviceIdentifier;
            }
            matchesSid=(sid)=>serviceIdentifiers.indexOf(sid)!==-1
        }
        return matchesSid;
    }
    unbindBindings(filter:(binding:interfaces.Binding<any>)=>boolean){
        this.bd.removeByCondition(filter);
        return this;
    }
    unbindTo(ctor:interfaces.Newable<any>,serviceIdentifer?:ServiceIdentifierOrArray){
        const matchesSid=this.getSidMatcher(serviceIdentifer);
        this.unbindBindings((b)=>{
            let remove=false;
            if(matchesSid(b.serviceIdentifier)){
                if(b.type===BindingTypeEnum.Instance){
                    remove=b.implementationType===ctor;
                }
            }
            return remove;
        })
        return this;
    }
    
    replaceToValue(oldCtor:interfaces.Newable<any>,newCtor:interfaces.Newable<any>,serviceIdentifer?:ServiceIdentifierOrArray){
        const matchesSid=this.getSidMatcher(serviceIdentifer);
        this.bd.traverse((sid,bindings)=>{
            if(matchesSid(sid)){
                for(let i=0;i<bindings.length;i++){
                    const binding=bindings[i];
                    if(binding.type===BindingTypeEnum.Instance&&binding.implementationType===oldCtor){
                        binding.cache=undefined;
                        binding.activated=false;
                        binding.implementationType=newCtor;
                        break;
                    }
                }
            }
        })
        return this;
    }
    unbindTarget(key:string,string | number | symbol:string,serviceIdentifer?:ServiceIdentifierOrArray){
        const matchesSid=this.getSidMatcher(serviceIdentifer);
        this.unbindBindings((b)=>{
            let found=false;
            if(matchesSid(b.serviceIdentifier)){
                found=this.bindingMatchesTarget(b,key,value);
            }
            return found;
        })
        return this;
    }
    
    unbindNamed(name:string,serviceIdentifer?:ServiceIdentifierOrArray){
        return this.unbindTarget(METADATA_KEY.NAMED_TAG,name,serviceIdentifer);
    }
    
    
    replaceTargetValue(key:string | number | symbol,value:string,newValue:any,serviceIdentifier?:ServiceIdentifierOrArray){
        const matchesSid=this.getSidMatcher(serviceIdentifier);
        this.bd.traverse((sid,bindings)=>{
            if(matchesSid(sid)){
                for(let i=0;i<bindings.length;i++){
                    const binding=bindings[i];
                    if(this.bindingMatchesTarget(binding,key,value)){
                        this.replaceBindingValue(binding,newValue);
                    }
                }
            }
        })
        return this;
    }
    replaceNamedValue(name:string,newValue:any,serviceIdentifier?:ServiceIdentifierOrArray){
        return this.replaceTargetValue(METADATA_KEY.NAMED_TAG,name,newValue,serviceIdentifier);
    }

}

describe('https://github.com/inversify/InversifyJS/issues/447',()=>{
    it('RebindContainer should replace named value',()=>{
        const container=new RebindContainer();
        interface IDirectory{
            path:string
        }

        @injectable()
        class ActiveDirectory{
            getDirectory():IDirectory{
                throw new Error('This is being mocked');
            }
        }
        @injectable()
        class MockActiveDirectory {
            getDirectory():IDirectory{
                return {
                    path:'MockPath'
                }
            }
        }
        @injectable()
        class OtherHelper{}
        container.bind<ActiveDirectory>('Helper').to(ActiveDirectory).inSingletonScope().whenTargetNamed('ActiveDirectory');
        container.bind<OtherHelper>('Helper').to(OtherHelper).inSingletonScope().whenTargetNamed('OtherHelper');
        expect(container.getNamed('Helper','ActiveDirectory')).toBeInstanceOf(ActiveDirectory);
        container.replaceNamedValue('ActiveDirectory',MockActiveDirectory);
        @injectable()
        class UsesActiveDirectory{
            constructor(@inject('Helper') @named('ActiveDirectory')  private readonly activeDirectory:ActiveDirectory ){}
            useActiveDirectory(){
                return this.activeDirectory.getDirectory().path;
            }
        }
        expect(container.resolve(UsesActiveDirectory).useActiveDirectory()).toEqual('MockPath');

    })
})

[notaphplover]

Hey, since inversify@7.2.0 you can now unbind a single binding. Refer to the docs for more information.