alepha 0.14.1 → 0.14.3

package/src/core/__tests__/Alepha-start.spec.ts

@@ -0,0 +1,176 @@
+import { $env, $hook, $inject, Alepha, ContainerLockedError, t } from "alepha";
+import { describe, expect, it } from "vitest";
+
+describe("Alepha#start", () => {
+  /**
+   * Start the application.
+   *
+   * Start act like a lock, it will prevent any further registration.
+   */
+  it("should start application successfully", async () => {
+    const app = await Alepha.create().start();
+
+    // Start again has no effect.
+    await app.start();
+    await app.start();
+  });
+
+  it("should lock container after start", async () => {
+    class A {
+      a = "a";
+      e = $env(
+        t.object({
+          HELLO: t.text(),
+        }),
+      );
+    }
+
+    const app = await Alepha.create({ env: { HELLO: "WORLD", MISSING: "123" } })
+      .with(A)
+      .start();
+
+    // you can't register after start.
+    expect(() => app.with(class {})).toThrow(ContainerLockedError);
+
+    // you can't get after start.
+    expect(() => app.inject(class {})).toThrow(ContainerLockedError);
+  });
+
+  /**
+   * B -> A so:
+   *
+   * - B should be configured after A.
+   * - B should be started after A.
+   *
+   * But also:
+   * - B should be stopped before A.
+   */
+  it("should execute hooks in correct order", async () => {
+    const stack: string[] = [];
+
+    class A {
+      onConfigure = $hook({
+        on: "configure",
+        handler: async () => {
+          stack.push("A.configure");
+        },
+      });
+
+      onStart = $hook({
+        on: "start",
+        handler: async () => {
+          stack.push("A.start");
+        },
+      });
+
+      onStop = $hook({
+        on: "stop",
+        handler: async () => {
+          stack.push("A.stop");
+        },
+      });
+    }
+
+    class B {
+      a = $inject(A);
+
+      onConfigure = $hook({
+        on: "configure",
+        handler: async () => {
+          stack.push("B.configure");
+        },
+      });
+
+      onStart = $hook({
+        on: "start",
+        handler: async () => {
+          stack.push("B.start");
+        },
+      });
+
+      onStop = $hook({
+        on: "stop",
+        handler: async () => {
+          stack.push("B.stop");
+        },
+      });
+    }
+
+    const app = await Alepha.create().with(B).start();
+
+    await app.start();
+    await app.start();
+
+    expect(stack).toEqual(["A.configure", "B.configure", "A.start", "B.start"]);
+
+    await app.stop();
+
+    expect(stack).toEqual([
+      "A.configure",
+      "B.configure",
+      "A.start",
+      "B.start",
+      "B.stop",
+      "A.stop",
+    ]);
+
+    await app.stop();
+
+    expect(stack).toEqual([
+      "A.configure",
+      "B.configure",
+      "A.start",
+      "B.start",
+      "B.stop",
+      "A.stop",
+    ]);
+  });
+
+  it("should support restart lifecycle", async () => {
+    let count = 0;
+
+    const alepha = Alepha.create().with(
+      class App {
+        configure = $hook({
+          on: "configure",
+          handler: () => {
+            count += 10;
+          },
+        });
+
+        start = $hook({
+          on: "start",
+          handler: () => {
+            count += 100;
+          },
+        });
+
+        stop = $hook({
+          on: "stop",
+          handler: () => {
+            count += 1000;
+          },
+        });
+      },
+    );
+
+    expect(alepha.isConfigured()).toBe(false);
+    expect(alepha.isLocked()).toBe(false);
+    expect(alepha.isStarted()).toBe(false);
+    expect(count).toBe(0);
+
+    await alepha.start();
+
+    expect(alepha.isConfigured()).toBe(true);
+    expect(alepha.isLocked()).toBe(true);
+    expect(alepha.isStarted()).toBe(true);
+    expect(count).toBe(110);
+
+    await alepha.stop();
+
+    expect(alepha.isConfigured()).toBe(true);
+    expect(alepha.isLocked()).toBe(true);
+    expect(alepha.isStarted()).toBe(false);
+    expect(count).toBe(1110);
+  });
+});

package/src/core/__tests__/Alepha-with.spec.ts

@@ -0,0 +1,14 @@
+import { Alepha } from "alepha";
+import { expect, test } from "vitest";
+
+test("Alepha#with - from default import", async () => {
+  const alepha = Alepha.create();
+
+  alepha.with(await import("./fixtures/A.js"));
+
+  const graph = alepha.graph();
+
+  expect(graph.A).toEqual({
+    from: ["Alepha"],
+  });
+});

package/src/core/__tests__/TypeBox-usecases.spec.ts

@@ -0,0 +1,35 @@
+import { Alepha, t } from "alepha";
+import { describe, expect, it } from "vitest";
+
+describe("TypeBox Use Cases", () => {
+  it("should remove property when omitted in schema with t.interface()", () => {
+    const entity = t.object({
+      id: t.integer(),
+      name: t.string(),
+      retryCount: t.optional(t.nullable(t.integer())),
+    });
+
+    const testPageSchema = t.object({
+      content: t.array(t.extend(t.omit(entity, ["retryCount"]), {})),
+    });
+
+    const testObject = {
+      content: [
+        {
+          id: 1,
+          name: "Test",
+          retryCount: null,
+        },
+      ],
+    };
+
+    const alepha = Alepha.create();
+
+    const result = alepha.codec.decode(testPageSchema, testObject);
+
+    expect(result.content[0]).toStrictEqual({
+      id: 1,
+      name: "Test",
+    });
+  });
+});

package/src/core/__tests__/TypeBoxLocale.spec.ts

@@ -0,0 +1,15 @@
+import { describe, it } from "vitest";
+
+describe("TypeBoxLocale", () => {
+  it("should have tests", async () => {
+    // const boom = async () => {
+    //   Alepha.create().codec.decode(t.number(), "...");
+    // };
+    //
+    // const error = await boom().catch((err) => err);
+    // expect(error).toBeInstanceOf(TypeBoxError);
+    // expect(error.cause.message).toBe("must be number");
+    // expect(TypeProvider.translateError(error)).toBe("must be number");
+    // expect(TypeProvider.translateError(error, "fr")).toBe("doit être number");
+  });
+});

package/src/core/__tests__/descriptor.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { Alepha } from "../Alepha.ts";
+import { KIND } from "../constants/KIND.ts";
+import { createPrimitive, Primitive } from "../helpers/primitive.ts";
+
+describe("primitive", () => {
+  it("should create custom primitives with key and identity methods", () => {
+    class MyPrimitive extends Primitive<{ name?: string }> {
+      key() {
+        return this.options.name ?? this.config.propertyKey;
+      }
+      identity() {
+        return `${this.config.service.name}:${this.key()}`;
+      }
+    }
+
+    const $my = (options: { name?: string } = {}) =>
+      createPrimitive(MyPrimitive, options);
+
+    $my[KIND] = MyPrimitive;
+
+    class TestApp {
+      h1 = $my();
+      h2 = $my({ name: "hello" });
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(TestApp);
+
+    expect(app.h1.key()).toBe("h1");
+    expect(app.h2.key()).toBe("hello");
+    expect(app.h2.identity()).toBe("TestApp:hello");
+  });
+});

package/src/core/__tests__/fixtures/A.ts

@@ -0,0 +1,5 @@
+class A {
+  value = "a";
+}
+
+export default A;

package/src/core/__tests__/pagination.spec.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { createPagination, pageSchema, t } from "../index.ts";
+
+describe("Pagination (Core)", () => {
+  it("should create pagination from any array", () => {
+    const items = Array.from({ length: 25 }, (_, i) => ({
+      id: i + 1,
+      name: `Item ${i + 1}`,
+    }));
+
+    // Simulate fetching limit + 1 items
+    const fetchedItems = items.slice(0, 11); // First page with 10 items + 1 for hasNext
+
+    const page = createPagination(fetchedItems, 10, 0);
+
+    expect(page.content.length).toBe(10);
+    expect(page.page.number).toBe(0);
+    expect(page.page.size).toBe(10);
+    expect(page.page.offset).toBe(0);
+    expect(page.page.numberOfElements).toBe(10);
+    expect(page.page.isEmpty).toBe(false);
+    expect(page.page.isFirst).toBe(true);
+    expect(page.page.isLast).toBe(false);
+  });
+
+  it("should handle empty results", () => {
+    const page = createPagination([], 10, 0);
+
+    expect(page.content.length).toBe(0);
+    expect(page.page.isEmpty).toBe(true);
+    expect(page.page.isFirst).toBe(true);
+    expect(page.page.isLast).toBe(true);
+    expect(page.page.numberOfElements).toBe(0);
+  });
+
+  it("should handle last page correctly", () => {
+    const items = [{ id: 1 }, { id: 2 }, { id: 3 }]; // Last 3 items
+
+    const page = createPagination(items, 10, 20);
+
+    expect(page.content.length).toBe(3);
+    expect(page.page.number).toBe(2);
+    expect(page.page.offset).toBe(20);
+    expect(page.page.numberOfElements).toBe(3);
+    expect(page.page.isFirst).toBe(false);
+    expect(page.page.isLast).toBe(true);
+  });
+
+  it("should include sort metadata", () => {
+    const items = [{ id: 1 }, { id: 2 }];
+
+    const page = createPagination(items, 10, 0, [
+      { column: "name", direction: "asc" },
+      { column: "createdAt", direction: "desc" },
+    ]);
+
+    expect(page.page.sort).toBeDefined();
+    expect(page.page.sort?.sorted).toBe(true);
+    expect(page.page.sort?.fields).toEqual([
+      { field: "name", direction: "asc" },
+      { field: "createdAt", direction: "desc" },
+    ]);
+  });
+
+  it("should create page schema", () => {
+    const itemSchema = t.object({
+      id: t.integer(),
+      name: t.text(),
+    });
+
+    const schema = pageSchema(itemSchema);
+
+    expect(schema).toBeDefined();
+    expect(schema.properties.content).toBeDefined();
+    expect(schema.properties.page).toBeDefined();
+  });
+});

package/src/core/helpers/jsonSchemaToTypeBox.ts

@@ -196,9 +196,9 @@ function convertString(schema: JsonSchemaObject): TSchema {
     default:
       // For unknown formats, preserve the format in text
       if (schema.format) {
-        return t.text({ ...options, format: schema.format });
+        return t.string({ ...options, format: schema.format });
       }
-      return t.text(options);
+      return t.string(options);
   }
 }
 

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

@@ -0,0 +1,43 @@
+import { Alepha, type State } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $atom } from "../primitives/$atom.ts";
+import { $use } from "../primitives/$use.ts";
+import { t } from "../providers/TypeProvider.ts";
+
+describe("$atom", () => {
+  const count = $atom({
+    name: "count",
+    schema: t.object({
+      value: t.number(),
+    }),
+    default: {
+      value: 0,
+    },
+  });
+
+  class App {
+    count = $use(count);
+  }
+
+  it("should be get/set with state manager", () => {
+    const alepha = Alepha.create();
+
+    expect(alepha.store.get(count).value).toBe(0);
+
+    alepha.store.set(count, { value: 42 });
+    expect(alepha.store.get(count).value).toBe(42);
+  });
+
+  it("should create virtual getter", () => {
+    const alepha = Alepha.create();
+    const app = alepha.inject(App);
+
+    expect(app.count.value).toBe(0);
+
+    alepha.store.set(count, { value: 42 });
+    expect(app.count.value).toBe(42);
+
+    alepha.store.set("count" as keyof State, { value: 23 });
+    expect(app.count.value).toBe(23);
+  });
+});

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

@@ -0,0 +1,130 @@
+import { $hook, $inject, Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+
+describe("$hook", () => {
+  it("should track hook calls", async () => {
+    class App {
+      hook = $hook({
+        on: "echo",
+        handler: () => {},
+      });
+    }
+    const alepha = Alepha.create().with(App);
+    await alepha.start();
+    expect(alepha.inject(App).hook.called).toBe(0);
+    await alepha.events.emit("echo", {});
+    expect(alepha.inject(App).hook.called).toBe(1);
+    await alepha.events.emit("echo", {});
+    expect(alepha.inject(App).hook.called).toBe(2);
+  });
+
+  it("should handle service substitution", async () => {
+    let count = 0;
+
+    class Interface {
+      n = 10;
+      c = $hook({
+        on: "configure",
+        handler: () => {
+          count += this.n;
+        },
+      });
+    }
+
+    const app = new Alepha();
+
+    expect(count).toBe(0);
+
+    class Impl extends Interface {
+      n = 1;
+      id = Math.random();
+    }
+
+    app.with({
+      provide: Interface,
+      use: Impl, // expects to be swapped, event from "Interface" will be deleted
+    });
+
+    expect(count).toBe(0);
+
+    await app.start();
+
+    expect(count).toBe(1);
+  });
+
+  it("should respect priority, before, and after ordering", async () => {
+    let stack = "";
+
+    class A {
+      _ = $hook({
+        on: "configure",
+        handler: () => {
+          stack += "A";
+        },
+      });
+    }
+
+    class B {
+      a = $inject(A);
+      _ = $hook({
+        on: "configure",
+        after: [this.a],
+        handler: () => {
+          stack += "B";
+        },
+      });
+    }
+
+    class C {
+      b = $inject(B);
+      _ = $hook({
+        on: "configure",
+        after: [this.b],
+        handler: () => {
+          stack += "C";
+        },
+      });
+    }
+
+    class D {
+      b = $inject(B);
+      c = $inject(C);
+      _ = $hook({
+        on: "configure",
+        after: [this.b, this.c],
+        handler: () => {
+          stack += "D";
+        },
+      });
+    }
+
+    class F {
+      _ = $hook({
+        priority: "last",
+        on: "configure",
+        handler: () => {
+          stack += "F";
+        },
+      });
+    }
+
+    class E {
+      d = $inject(D);
+      f = $inject(F);
+      _ = $hook({
+        on: "configure",
+        after: [this.d],
+        before: [this.f],
+        handler: () => {
+          stack += "E";
+        },
+      });
+    }
+
+    const alepha = Alepha.create().with(F).with(B).with(E);
+
+    await alepha.start();
+
+    expect(stack).toBe("ABCDEF");
+  });
+});