@praxisjs/di 1.3.13 → 1.3.15

package/src/__tests__/container.test.ts

@@ -1,247 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Container, Token, token, type Constructor } from "../container";
-
-describe("Token", () => {
-  it("stores description", () => {
-    const t = new Token("MY_SERVICE");
-    expect(t.description).toBe("MY_SERVICE");
-  });
-
-  it("toString includes description", () => {
-    const t = new Token("FOO");
-    expect(t.toString()).toBe("Token(FOO)");
-  });
-
-  it("token() factory creates a Token", () => {
-    const t = token<string>("DB_URL");
-    expect(t).toBeInstanceOf(Token);
-    expect(t.description).toBe("DB_URL");
-  });
-});
-
-describe("Container", () => {
-  it("registers and resolves a singleton service", () => {
-    class MyService {}
-    const c = new Container();
-    c.register(MyService);
-    const a = c.resolve(MyService);
-    const b = c.resolve(MyService);
-    expect(a).toBeInstanceOf(MyService);
-    expect(a).toBe(b); // singleton
-  });
-
-  it("creates new instance for transient scope", () => {
-    class Counter {
-      value = Math.random();
-    }
-    const c = new Container();
-    c.register(Counter, { scope: "transient" });
-    const a = c.resolve(Counter);
-    const b = c.resolve(Counter);
-    expect(a).not.toBe(b);
-  });
-
-  it("throws when resolving unregistered service", () => {
-    class Unknown {}
-    const c = new Container();
-    expect(() => c.resolve(Unknown)).toThrow("[DI] Service not registered");
-  });
-
-  it("registerValue stores a value by token", () => {
-    const DB_URL = token<string>("DB_URL");
-    const c = new Container();
-    c.registerValue(DB_URL, "postgres://localhost/db");
-    expect(c.resolve(DB_URL)).toBe("postgres://localhost/db");
-  });
-
-  it("registerFactory computes value via factory", () => {
-    const MAX = token<number>("MAX");
-    const c = new Container();
-    c.registerFactory(MAX, () => 100);
-    expect(c.resolve(MAX)).toBe(100);
-  });
-
-  it("throws for unregistered token", () => {
-    const t = token<string>("MISSING");
-    const c = new Container();
-    expect(() => c.resolve(t)).toThrow("[DI] Token not registered");
-  });
-
-  it("child container resolves from parent", () => {
-    const URL_TOKEN = token<string>("URL");
-    const parent = new Container();
-    parent.registerValue(URL_TOKEN, "https://example.com");
-    const child = parent.createChild();
-    expect(child.resolve(URL_TOKEN)).toBe("https://example.com");
-  });
-
-  it("child container can override parent registration", () => {
-    const URL_TOKEN = token<string>("URL");
-    const parent = new Container();
-    parent.registerValue(URL_TOKEN, "https://parent.com");
-    const child = parent.createChild();
-    child.registerValue(URL_TOKEN, "https://child.com");
-    expect(child.resolve(URL_TOKEN)).toBe("https://child.com");
-    expect(parent.resolve(URL_TOKEN)).toBe("https://parent.com");
-  });
-
-  it("register() is chainable", () => {
-    class A {}
-    class B {}
-    const c = new Container();
-    expect(c.register(A).register(B)).toBe(c);
-  });
-
-  it("parent singleton is reused when resolved from child container", () => {
-    class SharedService {}
-    const parent = new Container();
-    parent.register(SharedService, { scope: "singleton" });
-    const child = parent.createChild();
-
-    const fromChild = child.resolve(SharedService);
-    const fromParent = parent.resolve(SharedService);
-    expect(fromChild).toBe(fromParent);
-  });
-
-  it("child container falls back to parent for unregistered service", () => {
-    class MyDep {}
-    const parent = new Container();
-    parent.register(MyDep);
-    const child = parent.createChild();
-    expect(child.resolve(MyDep)).toBeInstanceOf(MyDep);
-  });
-
-  it("grandchild resolves from grandparent (three-level chain)", () => {
-    const URL_TOKEN = token<string>("GRANDPARENT_URL");
-    const grandparent = new Container();
-    grandparent.registerValue(URL_TOKEN, "https://grandparent.com");
-    const child = grandparent.createChild();
-    const grandchild = child.createChild();
-    expect(grandchild.resolve(URL_TOKEN)).toBe("https://grandparent.com");
-  });
-
-  it("registerFactory can resolve other services from the container", () => {
-    class Logger {}
-    const LOG_WRAP = token<{ logger: Logger }>("LOG_WRAP");
-    const c = new Container();
-    c.register(Logger);
-    c.registerFactory(LOG_WRAP, (container) => ({
-      logger: container.resolve(Logger),
-    }));
-    const result = c.resolve(LOG_WRAP);
-    expect(result.logger).toBeInstanceOf(Logger);
-  });
-
-  it("registering the same class twice replaces the previous registration", () => {
-    class Counter {
-      value = Math.random();
-    }
-    const c = new Container();
-    c.register(Counter, { scope: "singleton" });
-    const first = c.resolve(Counter);
-
-    // Re-register resets the descriptor (no cached instance)
-    c.register(Counter, { scope: "singleton" });
-    const second = c.resolve(Counter);
-
-    // After re-registration, a new singleton is created
-    expect(second).toBeInstanceOf(Counter);
-    expect(second).not.toBe(first);
-  });
-
-  it("re-registering with different scope switches scope correctly", () => {
-    class Svc {}
-    const c = new Container();
-    c.register(Svc, { scope: "singleton" });
-    c.resolve(Svc); // warm up singleton
-
-    c.register(Svc, { scope: "transient" });
-    const a = c.resolve(Svc);
-    const b = c.resolve(Svc);
-    expect(a).toBeInstanceOf(Svc);
-    expect(a).not.toBe(b);
-  });
-
-  it("factory function that throws — error message includes which service failed", () => {
-    class Broken {
-      constructor() {
-        throw new Error("boom");
-      }
-    }
-    const c = new Container();
-    c.register(Broken);
-    expect(() => c.resolve(Broken)).toThrow("Broken");
-    expect(() => c.resolve(Broken)).toThrow("[DI] Failed to instantiate");
-  });
-
-  it("resolve() called concurrently on the same uninitialized singleton — returns same instance or does not crash", async () => {
-    class SlowService {}
-    const c = new Container();
-    c.register(SlowService, { scope: "singleton" });
-
-    const [a, b] = await Promise.all([
-      Promise.resolve(c.resolve(SlowService)),
-      Promise.resolve(c.resolve(SlowService)),
-    ]);
-
-    expect(a).toBeInstanceOf(SlowService);
-    expect(a).toBe(b);
-  });
-
-  it("re-registering a service clears the previous singleton instance", () => {
-    class Svc {
-      id = Math.random();
-    }
-    const c = new Container();
-    c.register(Svc, { scope: "singleton" });
-    const first = c.resolve(Svc);
-
-    c.register(Svc, { scope: "singleton" });
-    const second = c.resolve(Svc);
-
-    expect(second).not.toBe(first);
-  });
-
-  it("circular dependency chain including a Token shows the Token name in the error", () => {
-    const MY_TOKEN = token<unknown>("MyToken");
-    const c = new Container();
-    c.registerValue(MY_TOKEN, "value");
-
-    // Pre-populate the stack as if we are already in the middle of resolving MY_TOKEN
-    const stack = new Set<Constructor | Token<unknown>>([MY_TOKEN]);
-    expect(() => c.resolve(MY_TOKEN, stack)).toThrow("Token(MyToken)");
-  });
-
-  it("circular dependency chain with a Constructor shows the class name (k.name branch)", () => {
-    class ServiceA {}
-    const c = new Container();
-    c.register(ServiceA);
-
-    // Pre-populate the stack as if ServiceA is already being resolved
-    const stack = new Set<Constructor | Token<unknown>>([ServiceA]);
-    expect(() => c.resolve(ServiceA as never, stack)).toThrow("ServiceA");
-  });
-
-  it("instantiate rethrows DI errors thrown inside a constructor without wrapping", () => {
-    const c = new Container();
-    class Unregistered {}
-    class Outer {
-      constructor() {
-        // Manually triggers a [DI] error inside the constructor body
-        c.resolve(Unregistered);
-      }
-    }
-    c.register(Outer);
-
-    const err = (() => {
-      try {
-        c.resolve(Outer);
-      } catch (e) {
-        return e as Error;
-      }
-    })()!;
-    expect(err.message).toMatch(/\[DI\] Service not registered/);
-    expect(err.message).not.toMatch(/Failed to instantiate/);
-  });
-});

package/src/__tests__/decorators.test.ts

@@ -1,343 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-import { Container, container, token } from "../container";
-import { Injectable, Inject, InjectContainer, Scope, inject } from "../decorators";
-
-function makeFieldCtx(name: string) {
-  const initializers: Array<(this: unknown) => void> = [];
-  return {
-    ctx: {
-      name,
-      kind: "field" as const,
-      addInitializer(fn: (this: unknown) => void) {
-        initializers.push(fn);
-      },
-    } as ClassFieldDecoratorContext,
-    run(instance: unknown) {
-      initializers.forEach((fn) => {
-        fn.call(instance);
-      });
-    },
-  };
-}
-
-// ── @Injectable ───────────────────────────────────────────────────────────────
-
-describe("Injectable", () => {
-  it("with no arguments — defaults to singleton scope", () => {
-    @Injectable()
-    class SingletonByDefault {}
-    const a = container.resolve(SingletonByDefault);
-    const b = container.resolve(SingletonByDefault);
-    expect(a).toBe(b);
-  });
-
-  it("registers the class in the global container", () => {
-    @Injectable()
-    class MyService {
-      greet() {
-        return "hello";
-      }
-    }
-    expect(container.resolve(MyService)).toBeInstanceOf(MyService);
-    expect(container.resolve(MyService).greet()).toBe("hello");
-  });
-
-  it("registers with transient scope — each resolve returns a new instance", () => {
-    @Injectable({ scope: "transient" })
-    class TmpService {}
-    expect(container.resolve(TmpService)).not.toBe(
-      container.resolve(TmpService),
-    );
-  });
-});
-
-// ── @Inject ───────────────────────────────────────────────────────────────────
-
-describe("Inject", () => {
-  it("injects a registered service via property", () => {
-    @Injectable()
-    class Logger {
-      log(msg: string) {
-        return msg;
-      }
-    }
-
-    const { ctx, run } = makeFieldCtx("logger");
-    Inject(Logger)(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    expect(instance.logger).toBeInstanceOf(Logger);
-    // second access covers the cache-hit branch (line 62: !cache.has(this) === false)
-    expect(instance.logger).toBe(instance.logger);
-  });
-
-  it("throws a descriptive error when dep is not registered", () => {
-    class UnknownDep {}
-    const { ctx, run } = makeFieldCtx("dep");
-    Inject(UnknownDep)(undefined, ctx);
-    class MyClass {}
-    const instance = new MyClass() as Record<string, unknown>;
-    run(instance);
-    expect(() => instance.dep).toThrow("[Inject]");
-  });
-
-  it("warns on direct assignment in non-production", () => {
-    @Injectable()
-    class Dep2 {}
-    const { ctx, run } = makeFieldCtx("dep2");
-    Inject(Dep2)(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    instance.dep2 = "override";
-    expect(spy).toHaveBeenCalledWith(expect.stringContaining("[Inject]"));
-    spy.mockRestore();
-  });
-
-  it("returns cached value on second access (cache hit)", () => {
-    @Injectable()
-    class CachedService {
-      id = Math.random();
-    }
-
-    const { ctx, run } = makeFieldCtx("svc");
-    Inject(CachedService)(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-
-    const first = instance.svc;
-    const second = instance.svc;
-    expect(first).toBe(second); // same cached instance
-  });
-
-  it("does not warn on direct assignment in production mode", () => {
-    @Injectable()
-    class ProdDep {}
-    const { ctx, run } = makeFieldCtx("dep");
-    Inject(ProdDep)(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    vi.stubEnv("NODE_ENV", "production");
-    instance.dep = "override";
-    expect(spy).not.toHaveBeenCalled();
-
-    vi.unstubAllEnvs();
-    spy.mockRestore();
-  });
-
-  it("includes the Token description in the error when resolution fails", () => {
-    const MY_TOKEN = token<string>("MY_SERVICE");
-    const { ctx, run } = makeFieldCtx("svc");
-    Inject(MY_TOKEN)(undefined, ctx);
-    class Consumer {}
-    const instance = new Consumer() as Record<string, unknown>;
-    run(instance);
-    expect(() => instance.svc).toThrow("MY_SERVICE");
-  });
-
-  it("@Inject on an anonymous class — error message uses token description instead of empty class name", () => {
-    const ANON_TOKEN = token<string>("ANON_TOKEN");
-    const { ctx, run } = makeFieldCtx("val");
-    Inject(ANON_TOKEN)(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    expect(() => instance.val).toThrow("ANON_TOKEN");
-  });
-});
-
-// ── @InjectContainer ──────────────────────────────────────────────────────────
-
-describe("InjectContainer", () => {
-  it("injects the global container on an unscoped class", () => {
-    const { ctx, run } = makeFieldCtx("c");
-    InjectContainer()(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    expect(instance.c).toBeInstanceOf(Container);
-    expect(instance.c).toBe(container);
-  });
-
-  it("called multiple times on same instance — returns same container instance (cached)", () => {
-    const { ctx, run } = makeFieldCtx("c");
-    InjectContainer()(undefined, ctx);
-    const instance: Record<string, unknown> = {};
-    run(instance);
-    const first = instance.c;
-    const second = instance.c;
-    expect(first).toBe(second);
-  });
-});
-
-// ── @Scope ────────────────────────────────────────────────────────────────────
-
-describe("Scope", () => {
-  it("creates a child container per instance", () => {
-    @Scope()
-    class Widget {}
-    const { ctx, run } = makeFieldCtx("c");
-    InjectContainer()(undefined, ctx);
-
-    const a = new Widget() as Record<string, unknown>;
-    run(a);
-    const b = new Widget() as Record<string, unknown>;
-    run(b);
-
-    expect(a.c).toBeInstanceOf(Container);
-    expect(b.c).toBeInstanceOf(Container);
-    expect(a.c).not.toBe(b.c); // each instance gets its own scope
-    expect(a.c).not.toBe(container); // it's a child, not the root
-  });
-
-  it("services registered in configure are resolvable within the scope", () => {
-    const DB_URL = token<string>("DB_URL");
-
-    @Scope((c) => {
-      c.registerValue(DB_URL, "postgres://localhost");
-    })
-    class DataModule {}
-
-    const { ctx, run } = makeFieldCtx("db");
-    Inject(DB_URL)(undefined, ctx);
-
-    const instance = new DataModule() as Record<string, unknown>;
-    run(instance);
-
-    expect(instance.db).toBe("postgres://localhost");
-  });
-
-  it("@Inject resolves from the scoped container, not the global one", () => {
-    class ScopedRepo {}
-    // NOT registered in global container
-    const VERSION = token<string>("VERSION");
-
-    @Scope((c) => {
-      c.register(ScopedRepo);
-      c.registerValue(VERSION, "2.0");
-    })
-    class App {}
-
-    const { ctx: repoCtx, run: runRepo } = makeFieldCtx("repo");
-    Inject(ScopedRepo)(undefined, repoCtx);
-    const { ctx: verCtx, run: runVer } = makeFieldCtx("version");
-    Inject(VERSION)(undefined, verCtx);
-
-    const instance = new App() as Record<string, unknown>;
-    runRepo(instance);
-    runVer(instance);
-
-    expect(instance.repo).toBeInstanceOf(ScopedRepo);
-    expect(instance.version).toBe("2.0");
-  });
-
-  it("@InjectContainer returns the scoped child container", () => {
-    @Scope((c) => {
-      c.registerValue(token<number>("X"), 42);
-    })
-    class Service {}
-
-    const { ctx, run } = makeFieldCtx("container");
-    InjectContainer()(undefined, ctx);
-
-    const instance = new Service() as Record<string, unknown>;
-    run(instance);
-
-    expect(instance.container).toBeInstanceOf(Container);
-    expect(instance.container).not.toBe(container);
-  });
-
-  it("child container inherits registrations from the parent", () => {
-    @Injectable()
-    class GlobalService {}
-
-    @Scope()
-    class Child {}
-
-    const { ctx, run } = makeFieldCtx("svc");
-    Inject(GlobalService)(undefined, ctx);
-    const instance = new Child() as Record<string, unknown>;
-    run(instance);
-
-    expect(instance.svc).toBeInstanceOf(GlobalService);
-  });
-
-  it("@Scope on child class that inherits from @Scope parent — child gets own container", () => {
-    const PARENT_TOKEN = token<string>("PARENT_VAL");
-    const CHILD_TOKEN = token<string>("CHILD_VAL");
-
-    @Scope((c) => {
-      c.registerValue(PARENT_TOKEN, "parent");
-    })
-    class Parent {}
-
-    @Scope((c) => {
-      c.registerValue(CHILD_TOKEN, "child");
-    })
-    class Child extends (Parent as unknown as new () => object) {}
-
-    const { ctx: ctxC, run: runC } = makeFieldCtx("c");
-    InjectContainer()(undefined, ctxC);
-
-    const parentInstance = new Parent() as Record<string, unknown>;
-    runC(parentInstance);
-
-    const childInstance = new Child() as Record<string, unknown>;
-    runC(childInstance);
-
-    expect(parentInstance.c).toBeInstanceOf(Container);
-    expect(childInstance.c).toBeInstanceOf(Container);
-    // child has its own scoped container, different from the parent's
-    expect(childInstance.c).not.toBe(parentInstance.c);
-    expect(childInstance.c).not.toBe(container);
-  });
-});
-
-// ── inject() ──────────────────────────────────────────────────────────────────
-
-describe("inject", () => {
-  it("resolves a registered class from the global container", () => {
-    @Injectable()
-    class GreetService {
-      greet() { return "hi"; }
-    }
-    const svc = inject(GreetService);
-    expect(svc).toBeInstanceOf(GreetService);
-    expect(svc.greet()).toBe("hi");
-  });
-
-  it("returns the same singleton instance on repeated calls", () => {
-    @Injectable()
-    class SingletonSvc {}
-    expect(inject(SingletonSvc)).toBe(inject(SingletonSvc));
-  });
-
-  it("returns a new instance each time for transient scope", () => {
-    @Injectable({ scope: "transient" })
-    class TransientSvc {}
-    expect(inject(TransientSvc)).not.toBe(inject(TransientSvc));
-  });
-
-  it("resolves a registered token value", () => {
-    const API_URL = token<string>("API_URL");
-    container.registerValue(API_URL, "https://api.example.com");
-    expect(inject(API_URL)).toBe("https://api.example.com");
-  });
-
-  it("throws when the class is not registered", () => {
-    class Unregistered {}
-    expect(() => inject(Unregistered)).toThrow("[DI]");
-  });
-
-  it("throws when the token is not registered", () => {
-    const MISSING = token<string>("MISSING_TOKEN");
-    expect(() => inject(MISSING)).toThrow("MISSING_TOKEN");
-  });
-
-  it("result is identical to container.resolve() — same underlying call", () => {
-    @Injectable()
-    class EqService {}
-    expect(inject(EqService)).toBe(container.resolve(EqService));
-  });
-});

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "types": ["node"]
-  },
-  "include": ["src"]
-}