Using toDynamicValue instead of toFactory not possible?

[estrizhok]

Here , when talking about factories, it states that values provided by factories are singletons and suggests using toDynamicValue if one needs to change it:

By default, Factory has scope Singleton and if you want to change the scope of your factory, you can use toDynamicValue.

container.bind("Factory")
    .toDynamicValue((context: interfaces.Context) => {
        return (name: string) => new SomeClass(context.container.get(Logger), name)
    })
    .inRequestScope();

The thing is, there is no toDynamicValue overload that accepts such a construct. And this case is not covered by tests.

Generally, having a fluent syntax as a first-class citizen for registering services is awkward. It lacks in a few important aspects:

1. There is no single point thru which all fully configured binding are added, which would have been useful if one wants to log all registrations made in a container.
2. In case when some registrations' cases are not covered by the provided syntax, it might be not possible to workaround it. (As it seems to be case with the example above)
3. Current syntax does not allow for an easy way of exposing a component as several interfaces implemented by it, while ensuring the component has the same scope across all registrations.

container.bind<ISomething>("ISomething").to<Implementor>().inSingletonScope();
container.bind<ISomethingElse>("ISomethingElse").to<Implementor>().inSingletonScope();

container.get<ISomething>("ISomething");           // creates an instance of Implementor
container.get<ISomethingElse>("ISomethingElse");  // creates a NEW instance of Implementor

Even if the above it would have worked, I would still prefer autofac-style registrations, as being more concise:

container.register<Implementor>(Implementor)
         .as<ISomething>("ISomething")
         .as<ISomethingElse>("ISomethingElse")
         .inSingletonScope();

This is how I workaround it:

container.bind<Implementor>(Implementor).to(Implementor);
container.bind<ISomething>("ISomething").toService(Implementor);
container.bind<ISomethingElse>("ISomethingElse").toService(Implementor);

container.get<ISomething>("ISomething");           // creates an instance of Implementor
container.get<ISomethingElse>("ISomethingElse");  // returns the same instance

Note, the latter approach has a bug with regard to @preDestroy(): it will be called for each resolved instances of ISomething, ISomethingElse or Implementor, ending up calling it up to 3 times on the same instance.