feat: add @service decorator (#72)

* feat: add @service decorator

* fix: eslint

Author: lbguilherme

spec/inject.test.ts

@@ -1,14 +1,6 @@
 /* eslint-disable @typescript-eslint/no-shadow */
-import {
-  popInjectionContext,
-  pushInjectionContext,
-  registerValue,
-  registerScopedValue,
-  registerService,
-  setupScope,
-  use,
-  registerServiceWithFactory,
-} from "../src";
+import { popInjectionContext, pushInjectionContext, registerValue, registerScopedValue, registerService, setupScope, use } from "../src";
+import { Service } from "../src/service";
 
 describe("inject", () => {
   beforeEach(pushInjectionContext);
@@ -52,6 +44,7 @@ describe("inject", () => {
   it("registers a service as transient", () => {
     let constructorCalledTimes = 0;
 
+    @Service("transient")
     class TestService {
       public id = Math.random();
 
@@ -60,8 +53,6 @@ describe("inject", () => {
       }
     }
 
-    registerService("transient", TestService);
-
     expect(constructorCalledTimes).toBe(0);
 
     const instance1 = use(TestService);
@@ -429,19 +420,19 @@ describe("inject", () => {
   });
 
   it("allow registering a service with a custom factory function", () => {
-    class A {
-      id = 0;
-    }
-
     const factory = jest.fn(() => {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
       const instance = new A();
 
       instance.id = 1;
 
       return instance;
     });
 
-    registerServiceWithFactory("singleton", A, factory);
+    @Service("singleton", factory)
+    class A {
+      id = 0;
+    }
 
     expect(use(A)).toBeInstanceOf(A);
     expect(use(A).id).toBe(1);

src/global-context.ts

@@ -1,19 +1,19 @@
 import { randomBytes } from "crypto";
 
-import type { Service } from "./service";
+import type { ServiceSpec } from "./service";
 
 export class GlobalContext {
   id = randomBytes(32).toString("hex");
 
   constructor(public readonly parent?: GlobalContext) {}
 
-  private readonly services = new Map<string, Service>();
+  private readonly services = new Map<string, ServiceSpec>();
 
   private readonly singletonInstances = new Map<string, unknown>();
 
   private readonly values = new Map<string, unknown>();
 
-  getService(name: string): Service | undefined {
+  getService(name: string): ServiceSpec | undefined {
     let service = this.services.get(name);
 
     if (service) {
@@ -33,7 +33,7 @@ export class GlobalContext {
     return this.services.has(name);
   }
 
-  setService(name: string, value: Service) {
+  setService(name: string, value: ServiceSpec) {
     this.services.set(name, value);
   }
 

src/index.ts

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

src/service.ts

@@ -6,7 +6,7 @@ import { getCurrentScope } from "./scope-context";
 export type ServiceType = new (...args: any) => any;
 export type ServiceLifetime = "singleton" | "scoped" | "transient";
 
-export interface Service {
+export interface ServiceSpec {
   type: ServiceType;
   factory(): unknown;
   lifetime: ServiceLifetime;
@@ -15,7 +15,7 @@ export interface Service {
 const serviceConstructionStack: Function[] = [];
 const serviceConstructionLookup = new Set<Function>();
 
-function createServiceInstance(service: Service) {
+function createServiceInstance(service: ServiceSpec) {
   serviceConstructionStack.push(service.type);
 
   if (serviceConstructionLookup.has(service.type)) {
@@ -48,6 +48,13 @@ export function registerService<T extends ServiceType>(lifetime: ServiceLifetime
   registerServiceWithFactory(lifetime, type, () => new type(...(ctorArgs as unknown[])));
 }
 
+export function Service(lifetime: ServiceLifetime, factory?: () => unknown) {
+  return <T extends ServiceType>(type: T) => {
+    registerServiceWithFactory(lifetime, type, factory ? (factory as () => InstanceType<T>) : () => new type());
+    return type;
+  };
+}
+
 export function useService<T extends ServiceType>(type: T): InstanceType<T> {
   const service = getGlobalContext().getService(type.name);
 

tsconfig.json

@@ -5,7 +5,8 @@
     "declaration": true,
     "outDir": "./dist",
     "strict": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "experimentalDecorators": true
   },
   "files": [
     "src/index.ts",