Disposing container doesn't dispose instances created/registered with `useFactory` and `useValue` providers

[stalniy]

Describe the bug

Disposing container doesn't dispose instances created/registered with useFactory and useValue providers.

To Reproduce

import "reflect-metadata";
import { container } from 'tsyringe';

const APP_INIT = Symbol('APP_INIT')

container.register(APP_INIT, {
  useFactory: () => ({
     dispose: () => console.log('disposed from useFactory')
  })
});

container.register(APP_INIT, {
  useValue: {
     dispose: () => console.log('disposed from useValue')
  }
});

container.register(APP_INIT, {
  useClass: class {
    dispose() {
      console.log('disposed from useClass')
    }
  }
});

console.log(container.resolveAll(APP_INIT))
Promise.resolve(container.dispose()).then(() => console.log('container disposed'))

the output is:

[
  { dispose: [Function: dispose] },
  { dispose: [Function: dispose] },
  useClass {}
]
disposed from useClass
container disposed

Expected behavior

Documentation says

All instances created by the container that implement the Disposable interface will automatically be disposed of when the container is disposed.

So, I expect that all services that have .dispose method are disposed. At the bare minimum there should be a possibility to dispose factories and values. We use factories to provide APP_INITIALIZERs that can connect to db or remote socket and need to close this connections on shutdown

Version: 4.10.0

[lppedd]

Just an opinion here. In my own DI library I decided to implemented disposal for all providers, except for ValueProvider.
The reasoning is quite simple:

1. A static value doesn't have a scope.
   It is logical to dispose of container-cached values, which are generally Singleton/Container-scoped.
2. A static value's lifecycle is logically managed outside of the container. You're providing an already constructed object, that has no notion of the DI container, and you shouldn't expect the container to know about/manage it. Because of that, the value is returned immediately and is never cached.

[stalniy]

I see this thing more as a lifecycle hook not only as a way to dispose object.

In my case, I’m migrating codebase without DI where some service are exported via module export and for legacy reasons need to stay like this for some time. However I’d like to register them additionally in DI to write new code in a better way. But dispose functionality just doesn’t work for them if I provide it as a value.

Eventually it doesn’t really matter how we write it:

• container.register(token, { useFactory: () =>({ dispose: () => {} }) })
• or container.register(token, { useValue: { dispose: () => {} } })
• or container.register(token, class { dispose = () => {} })

Everything looks almost identical and doable even with the current restrictions. So, the only thing this restriction does is - produces awkward hacks to overcome it.

[lppedd]

I kinda get what you mean. Convenience is nice to have.

I agree that factory-provided values should be disposed, and probably value-provided values should be disposed under a container option (defaulting to false).

[lppedd]

If you're up to switch to an alternative DI container, this kind of behavior is now possible in di-wise-neo.