alepha 0.14.1 → 0.14.3

package/src/core/primitives/$inject.spec.ts

@@ -0,0 +1,175 @@
+import {
+  $context,
+  $env,
+  $inject,
+  Alepha,
+  CircularDependencyError,
+  type Service,
+  TypeBoxError,
+  t,
+} from "alepha";
+import { describe, expect, it } from "vitest";
+import { MissingContextError } from "../errors/MissingContextError.ts";
+
+describe("$inject", () => {
+  it("should inject dependencies correctly", () => {
+    class A {
+      hello = "world";
+    }
+
+    class B {
+      a = $inject(A);
+    }
+
+    class C {
+      b = $inject(B);
+      a = $inject(A);
+    }
+
+    const ctx = new Alepha();
+    const c1 = ctx.inject(C);
+    expect(c1.b.a.hello).toBe("world");
+
+    const c2 = ctx.inject(C);
+    c2.b.a.hello = "test";
+
+    expect(c1.b.a.hello).toBe("test");
+    expect(c2.b.a.hello).toBe("test");
+    expect(c2.a.hello).toBe("test");
+  });
+
+  it("should throw error when missing context", () => {
+    class A {}
+
+    class B {
+      a = $inject(A);
+    }
+
+    expect(() => new B()).toThrow(MissingContextError);
+  });
+});
+
+describe("$env", () => {
+  it("should inject environment variables correctly", () => {
+    class A {
+      env = $env(
+        t.object({
+          N1: t.text(),
+          N2: t.text({ default: "$N1" }),
+        }),
+      );
+    }
+
+    class B {
+      a = $inject(A);
+    }
+
+    class C {
+      b = $inject(B);
+    }
+
+    expect(
+      Alepha.create({ env: { N1: "abc" } }).inject(C).b.a.env,
+    ).toStrictEqual({
+      N1: "abc",
+      N2: "abc",
+    });
+
+    expect(
+      Alepha.create({ env: { N1: "abc", N2: "efg" } }).inject(C).b.a.env,
+    ).toStrictEqual({
+      N1: "abc",
+      N2: "efg",
+    });
+
+    expect(() => Alepha.create().inject(C)).toThrow(TypeBoxError);
+  });
+});
+
+describe("$inject - circular dependencies", () => {
+  it("should detect circular dependencies", () => {
+    const superInject = (type: Service) => {
+      const { alepha } = $context();
+      alepha.inject(Module); // <- trying to "#get" during a tree walk is bad
+
+      // consider using "#register" instead
+      // register check if the type is already registered (or pending) before calling #get
+
+      return alepha.inject(type);
+    };
+
+    class A {}
+
+    class Module {
+      a = superInject(A);
+    }
+
+    class Test {
+      hi = superInject(A);
+    }
+
+    expect(() => Alepha.create().inject(Test)).toThrow(
+      new CircularDependencyError("Module", ["Test"]),
+    );
+  });
+
+  it("should fix circular dependencies with proper registration", () => {
+    const superInject = <T extends object>(type: Service<T>): T => {
+      const { alepha } = $context();
+      alepha.with(Module); // <- replace .get by .with to fix circular dependency
+      return alepha.inject(type);
+    };
+
+    class A {
+      hello = "world";
+    }
+
+    class Module {
+      a = superInject(A);
+    }
+
+    class Test {
+      hi = superInject(A);
+    }
+
+    expect(Alepha.create().inject(Test).hi.hello).toBe("world");
+  });
+});
+
+describe("$inject - inheritance", () => {
+  it("should handle class inheritance correctly", () => {
+    const logs: string[] = [];
+    class P1 {
+      constructor() {
+        logs.push("P1");
+      }
+    }
+    class P2 {
+      constructor() {
+        logs.push("P2");
+      }
+    }
+
+    class R1 {
+      p1 = $inject(P1);
+    }
+
+    class R2 extends R1 {}
+
+    class R3 extends R1 {
+      p2 = $inject(P2);
+    }
+
+    const ctx = Alepha.create();
+
+    const r2 = ctx.inject(R2);
+    expect(r2.p1).toBeInstanceOf(P1);
+    expect(logs).toEqual(["P1"]);
+
+    const r3 = ctx.inject(R3);
+    expect(r3.p2).toBeInstanceOf(P2);
+
+    // just be to ensure that P1 is not created again (because R3 extends R1)
+    expect(logs).toEqual(["P1", "P2"]);
+  });
+});

package/src/core/primitives/$module.spec.ts

@@ -0,0 +1,115 @@
+import { $inject, $module, Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+
+describe("$module", () => {
+  it("should create a module with services", () => {
+    class VeryRandomService {}
+    class RandomService {
+      very = $inject(VeryRandomService);
+    }
+    const CoreModule = $module({
+      name: "core",
+      services: [RandomService, VeryRandomService],
+    });
+
+    class DatabaseService {}
+    const DatabaseModule = $module({
+      name: "database",
+      services: [DatabaseService],
+    });
+
+    class ServerProvider {}
+    const ServerModule = $module({
+      name: "server",
+      services: [CoreModule, DatabaseModule, ServerProvider],
+    });
+
+    const alepha = Alepha.create().with(ServerModule);
+
+    expect(alepha.graph()).toEqual({
+      VeryRandomService: { from: ["RandomService", "core"], module: "core" },
+      RandomService: { from: ["core"], module: "core" },
+      DatabaseService: { from: ["database"], module: "database" },
+      ServerProvider: { from: ["server"], module: "server" },
+      AlsProvider: {
+        from: ["StateManager", "Alepha"],
+        module: "alepha.core",
+      },
+      EventManager: {
+        from: ["StateManager", "Alepha"],
+        module: "alepha.core",
+      },
+      StateManager: {
+        from: ["Alepha"],
+        module: "alepha.core",
+      },
+      Json: {
+        from: ["JsonSchemaCodec"],
+        module: "alepha.core",
+      },
+      JsonSchemaCodec: {
+        from: ["StateManager", "CodecManager"],
+        module: "alepha.core",
+      },
+      CodecManager: {
+        from: ["Alepha"],
+        module: "alepha.core",
+      },
+      SchemaValidator: {
+        from: ["CodecManager"],
+        module: "alepha.core",
+      },
+    });
+  });
+
+  it("should auto inject all dependencies", async ({ expect }) => {
+    let stack = "";
+
+    class A {
+      constructor() {
+        stack += "A";
+      }
+      a = "a";
+    }
+
+    class A2 {
+      constructor() {
+        stack += "2";
+      }
+      a = "2";
+    }
+
+    class B {
+      constructor() {
+        stack += "B";
+      }
+    }
+
+    // note: we do not need to import MyModule,
+    // it will be registered automatically if A or B is injected
+    const MyModule = $module({
+      name: "my.module",
+      services: [A, B],
+      register: (alepha) => {
+        alepha.with(B); // load only B explicitly
+      },
+    });
+
+    const alepha = Alepha.create();
+
+    // substitute A with A2
+    alepha.with({
+      provide: A,
+      use: A2, // A2 will inherit of A's module
+    });
+
+    // should not be activated yet
+    expect(stack).toBe("");
+
+    // but now, we start, so all substitutions are applied
+    await alepha.start();
+
+    expect(stack).toBe("B2");
+    expect(alepha.inject(A).a).toBe("2");
+  });
+});