docs: extend README with usage examples (#13)

package.json

@@ -39,7 +39,7 @@
     "test:ci": "vitest run --silent --coverage",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
-    "reformat": "prettier src/**/*.ts --write"
+    "reformat": "prettier src/**/*.ts README.md --write"
   },
   "devDependencies": {
     "@eslint/js": "^9.10.0",

src/container.test.ts

@@ -18,12 +18,12 @@ describe("Container API", () => {
   });
 
   it("inject", () => {
-    expect(() => inject(MyService)).toThrowError('You can only invoke inject() from the injection context');
+    expect(() => inject(MyService)).toThrowError("You can only invoke inject() from the injection context");
 
     const container = new Container();
     const token = new InjectionToken<MyService>("some-token");
 
-    expect(() => container.get(token)).toThrowError('No provider(s) found');
+    expect(() => container.get(token)).toThrowError("No provider(s) found");
 
     container.bind({
       provide: token,
@@ -34,7 +34,7 @@ describe("Container API", () => {
   });
 
   it("injectAsync", async () => {
-    expect(() => injectAsync(MyService)).toThrowError('You can only invoke injectAsync() from the injection context');
+    expect(() => injectAsync(MyService)).toThrowError("You can only invoke injectAsync() from the injection context");
 
     const container = new Container();
     const token = new InjectionToken<string>("some-token");

src/decorators.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { getInjectableTargets, injectable, type InjectableClass } from './decorators.js';
+import { getInjectableTargets, injectable, type InjectableClass } from "./decorators.js";
 
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 abstract class AbstractService {}
@@ -20,23 +20,28 @@ class SpecialBazService extends BazService {}
 
 describe("Decorators", () => {
   it("should register every annotated class across its hierarchy", () => {
+    expect(getInjectableTargets(AbstractService as InjectableClass).map((it) => it.name)).toEqual([
+      "FooService",
+      "BarService",
+      "SpecialBarService",
+      "SpecialBazService",
+    ]);
 
-    expect(getInjectableTargets(AbstractService as InjectableClass).map(it => it.name))
-        .toEqual(['FooService', 'BarService', 'SpecialBarService', 'SpecialBazService'])
+    expect(getInjectableTargets(FooService as InjectableClass).map((it) => it.name)).toEqual(["FooService"]);
 
-    expect(getInjectableTargets(FooService as InjectableClass).map(it => it.name))
-        .toEqual(['FooService'])
+    expect(getInjectableTargets(BarService as InjectableClass).map((it) => it.name)).toEqual([
+      "BarService",
+      "SpecialBarService",
+    ]);
 
-    expect(getInjectableTargets(BarService as InjectableClass).map(it => it.name))
-        .toEqual(['BarService', 'SpecialBarService'])
+    expect(getInjectableTargets(SpecialBarService as InjectableClass).map((it) => it.name)).toEqual([
+      "SpecialBarService",
+    ]);
 
-    expect(getInjectableTargets(SpecialBarService as InjectableClass).map(it => it.name))
-        .toEqual(['SpecialBarService'])
+    expect(getInjectableTargets(BazService as InjectableClass).map((it) => it.name)).toEqual(["SpecialBazService"]);
 
-    expect(getInjectableTargets(BazService as InjectableClass).map(it => it.name))
-        .toEqual(['SpecialBazService'])
-
-    expect(getInjectableTargets(SpecialBazService as InjectableClass).map(it => it.name))
-        .toEqual(['SpecialBazService'])
+    expect(getInjectableTargets(SpecialBazService as InjectableClass).map((it) => it.name)).toEqual([
+      "SpecialBazService",
+    ]);
   });
 });

src/decorators.ts

@@ -1,26 +1,24 @@
-import type { Class } from "./utils.js";
+import { type AbstractClass, type Class, getParentClasses } from "./utils.js";
 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 type ClassDecorator<C extends Class<unknown>> = (target: C) => C | void;
 
 export const injectableSymbol = Symbol("injectable");
 
-export type InjectableClass<T = unknown> = Class<T> & { [injectableSymbol]: Class<unknown>[]};
+export type InjectableClass<T = unknown> = (Class<T> | AbstractClass<T>) & { [injectableSymbol]: Class<unknown>[] };
 
 export function injectable<C extends Class<unknown>>(): ClassDecorator<C> {
   return (target) => {
-    let superClass = Object.getPrototypeOf(target);
-    while (superClass.name) {
-      if (!Object.getOwnPropertyDescriptor(superClass, injectableSymbol)) {
-        Object.defineProperty(superClass, injectableSymbol, {
+    getParentClasses(target).forEach((parentClass) => {
+      if (!Object.getOwnPropertyDescriptor(parentClass, injectableSymbol)) {
+        Object.defineProperty(parentClass, injectableSymbol, {
           value: [target],
           writable: true,
         });
       } else {
-        superClass[injectableSymbol] = [...superClass[injectableSymbol], target];
+        parentClass[injectableSymbol] = [...parentClass[injectableSymbol], target];
       }
-      superClass = Object.getPrototypeOf(superClass);
-    }
+    });
 
     Object.defineProperty(target, injectableSymbol, {
       value: [target],
@@ -29,7 +27,7 @@ export function injectable<C extends Class<unknown>>(): ClassDecorator<C> {
   };
 }
 
-export function isInjectable<T>(target: Class<T>): target is InjectableClass<T> {
+export function isInjectable<T>(target: AbstractClass<T>): target is InjectableClass<T> {
   // eslint-disable-next-line no-prototype-builtins
   return target.hasOwnProperty(injectableSymbol);
 }

src/examples.test.ts

@@ -100,7 +100,7 @@ describe("Container", () => {
     const container = new Container();
     const service = container.get(MyService);
 
-    expect(() => service.triggerInject()).toThrowError('You can only invoke inject() from the injection context');
+    expect(() => service.triggerInject()).toThrowError("You can only invoke inject() from the injection context");
   });
 
   it("should support all kinds of providers", async () => {
@@ -149,10 +149,14 @@ describe("Container", () => {
 
     expect(factoryFn).toHaveBeenCalledTimes(1);
 
-    expect(() => container.get(tokenWithoutProvider)).toThrowError('No provider(s) found');
-    expect(() => container.get(tokenWithoutProvider, { optional: false })).toThrowError('No provider(s) found');
+    expect(() => container.get(tokenWithoutProvider)).toThrowError("No provider(s) found");
+    expect(() => container.get(tokenWithoutProvider, { optional: false })).toThrowError("No provider(s) found");
 
-    expect(() => container.get(tokenProvidedAsync)).toThrowError('use injectAsync() or container.getAsync() instead');
+    expect(() => container.get(tokenProvidedAsync)).toThrowError("use injectAsync() or container.getAsync() instead");
+
+    await container.getAsync(tokenProvidedAsync);
+
+    expect(() => container.get(tokenProvidedAsync)).not.toThrowError();
 
     const fooAsync = await container.getAsync(tokenProvidedAsync);
     expect(fooAsync).toEqual({ foo: "async" });

src/providers.test.ts

@@ -318,18 +318,18 @@ describe("Providers", () => {
     const MY_TOKEN = Symbol.for("my-token");
 
     container.bindAll(
-        {
-          provide: MY_TOKEN,
-          useFactory: () => Promise.resolve(1),
-          async: true,
-          multi: true,
-        },
-        {
-          provide: MY_TOKEN,
-          useFactory: () => Promise.resolve(2),
-          async: true,
-          multi: true,
-        },
+      {
+        provide: MY_TOKEN,
+        useFactory: () => Promise.resolve(1),
+        async: true,
+        multi: true,
+      },
+      {
+        provide: MY_TOKEN,
+        useFactory: () => Promise.resolve(2),
+        async: true,
+        multi: true,
+      },
     );
 
     expect(() => container.get(MY_TOKEN)).toThrowError("use injectAsync() or container.getAsync() instead");

src/utils.ts

@@ -1,5 +1,8 @@
+import type { InjectableClass } from "./decorators.js";
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Class<T> = new (...args: any[]) => T;
+
 export interface AbstractClass<T> {
   prototype: T;
   name: string;
@@ -8,3 +11,14 @@ export interface AbstractClass<T> {
 export function isClass(target: unknown): target is Class<unknown> | AbstractClass<unknown> {
   return typeof target === "function";
 }
+
+export function getParentClasses(target: Class<unknown>): InjectableClass[] {
+  const parentClasses: InjectableClass[] = [];
+  let currentClass = target as InjectableClass;
+  while (Object.getPrototypeOf(currentClass).name) {
+    const parentClass: InjectableClass = Object.getPrototypeOf(currentClass);
+    parentClasses.push(parentClass);
+    currentClass = parentClass;
+  }
+  return parentClasses;
+}