feat: add registerServiceWithFactory

Author: lbguilherme

README.md

@@ -42,7 +42,7 @@ The concept of "scope" can vary depending on the framework, but here we call "sc
 
 You are not required to setup a scope if you are not going to use scoped services or values.
 
-## `registerService(lifetime, class)`
+## `registerService(lifetime, class, ...args)` and `registerServiceWithFactory(lifetime, class, factory)`
 
 Registers a new service with the specified lifetime.
 
@@ -90,6 +90,12 @@ class CoolIntegrationService {
 registerService("transient", CoolIntegrationService, axios.create(), env.COOL_API_KEY);
 ```
 
+If you need some custom construction logic and for some reason the class constructor can't be used for that, you can use `registerServiceWithFactory`. This function will be called only when needed.
+
+```typescript
+registerServiceWithFactory("singleton", SomeService, () => SomeService.getInstance());
+```
+
 ## `use(class)`
 
 This function can be called from anywhere (including from the constructor of a service) to obtain an instance of a service ready to use. The lifetime of the service is handled behind the scenes.

spec/inject.test.ts

@@ -1,5 +1,14 @@
 /* eslint-disable @typescript-eslint/no-shadow */
-import { popInjectionContext, pushInjectionContext, registerValue, registerScopedValue, registerService, setupScope, use } from "../src";
+import {
+  popInjectionContext,
+  pushInjectionContext,
+  registerValue,
+  registerScopedValue,
+  registerService,
+  setupScope,
+  use,
+  registerServiceWithFactory,
+} from "../src";
 
 describe("env", () => {
   beforeEach(pushInjectionContext);
@@ -411,4 +420,24 @@ describe("env", () => {
       popInjectionContext();
     }
   });
+
+  it("allow registering a service with a custom factory function", () => {
+    class A {
+      id = 0;
+    }
+
+    const factory = jest.fn(() => {
+      const instance = new A();
+
+      instance.id = 1;
+
+      return instance;
+    });
+
+    registerServiceWithFactory("singleton", A, factory);
+
+    expect(use(A)).toBeInstanceOf(A);
+    expect(use(A).id).toBe(1);
+    expect(factory).toBeCalledTimes(1);
+  });
 });

src/index.ts

@@ -1,6 +1,6 @@
 export { pushInjectionContext, popInjectionContext } from "./global-context";
 export { setupScope } from "./scope-context";
-export { registerService } from "./service";
+export { registerService, registerServiceWithFactory } from "./service";
 export { registerScopedValue, registerValue } from "./value";
 export { use } from "./use";
 

src/service.ts

@@ -36,12 +36,16 @@ function createServiceInstance(service: Service) {
   }
 }
 
-export function registerService<T extends ServiceType>(lifetime: ServiceLifetime, type: T, ...ctorArgs: ConstructorParameters<T>) {
+export function registerServiceWithFactory<T extends ServiceType>(lifetime: ServiceLifetime, type: T, factory: () => InstanceType<T>) {
   if (getGlobalContext().hasServiceSkipParent(type.name)) {
     throw new Error(`Service '${type.name}' is already registered`);
   }
 
-  getGlobalContext().setService(type.name, { type, factory: () => new type(...(ctorArgs as unknown[])), lifetime });
+  getGlobalContext().setService(type.name, { type, factory, lifetime });
+}
+
+export function registerService<T extends ServiceType>(lifetime: ServiceLifetime, type: T, ...ctorArgs: ConstructorParameters<T>) {
+  registerServiceWithFactory(lifetime, type, () => new type(...(ctorArgs as unknown[])));
 }
 
 export function useService<T extends ServiceType>(type: T): InstanceType<T> {