alepha 0.14.1 → 0.14.3

package/src/core/providers/TypeProvider.ts

@@ -25,15 +25,9 @@ import type {
   TUnsafe,
 } from "typebox";
 import { Type } from "typebox";
-import type {
-  TLocalizedValidationError,
-  TLocalizedValidationMessageCallback,
-} from "typebox/error";
 import Format from "typebox/format";
-import { Locale } from "typebox/system";
 import * as Value from "typebox/value";
 import { OPTIONS } from "../constants/OPTIONS.ts";
-import { AlephaError } from "../errors/AlephaError.ts";
 import type { TypeBoxError } from "../errors/TypeBoxError.ts";
 import { isTypeFile, type TFile, type TStream } from "../helpers/FileLike.ts";
 
@@ -132,30 +126,30 @@ export class TypeProvider {
   }
 
   static translateError(error: TypeBoxError, locale?: string): string {
-    if (!locale) {
-      return error.cause.message;
-    }
-
-    for (const [key, value] of Object.entries(Locale)) {
-      if (key === "Set" || key === "Get" || key === "Reset") continue;
-      if (key === locale || key.startsWith(`${locale}_`)) {
-        return (value as (error: TLocalizedValidationError) => string)(
-          error.cause,
-        );
-      }
-    }
+    // if (!locale) {
+    //   return error.cause.message;
+    // }
+    //
+    // for (const [key, value] of Object.entries(Locale)) {
+    //   if (key === "Set" || key === "Get" || key === "Reset") continue;
+    //   if (key === locale || key.startsWith(`${locale}_`)) {
+    //     return (value as (error: TLocalizedValidationError) => string)(
+    //       error.cause,
+    //     );
+    //   }
+    // }
     return error.cause.message;
   }
 
   static setLocale(locale: string) {
-    for (const [key, value] of Object.entries(Locale)) {
-      if (key === "Set" || key === "Get" || key === "Reset") continue;
-      if (key === locale || key.startsWith(`${locale}_`)) {
-        Locale.Set(value as TLocalizedValidationMessageCallback);
-        return;
-      }
-    }
-    throw new AlephaError(`Locale not found: ${locale}`);
+    // for (const [key, value] of Object.entries(Locale)) {
+    //   if (key === "Set" || key === "Get" || key === "Reset") continue;
+    //   if (key === locale || key.startsWith(`${locale}_`)) {
+    //     Locale.Set(value as TLocalizedValidationMessageCallback);
+    //     return;
+    //   }
+    // }
+    // throw new AlephaError(`Locale not found: ${locale}`);
   }
 
   static isValidBigInt(value: string | number) {

package/src/datetime/primitives/$interval.spec.ts

@@ -0,0 +1,103 @@
+import { $hook, Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+import { $interval, DateTimeProvider } from "../index.ts";
+
+describe("$interval", () => {
+  it("should execute handler at specified intervals", async () => {
+    const count = { value: 0 };
+    class TestApp {
+      loop = $interval({
+        duration: [10, "seconds"],
+        handler: () => {
+          count.value += 1;
+        },
+      });
+    }
+
+    const alepha = Alepha.create({
+      env: {},
+    });
+    const dt = alepha.inject(DateTimeProvider);
+    const app = alepha.inject(TestApp);
+    expect(app.loop.called).toBe(0);
+    expect(count.value).toBe(0);
+
+    expect(app.loop.called).toBe(0);
+    expect(count.value).toBe(0);
+    await alepha.start();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(app.loop.called).toBe(1);
+    expect(count.value).toBe(1);
+
+    await dt.travel([50, "seconds"]);
+    expect(app.loop.called).toBe(6);
+    expect(count.value).toBe(6);
+  });
+
+  it("should stop interval on abort", async () => {
+    const count = { value: 0 };
+    class TestApp {
+      loop = $interval({
+        duration: [10, "seconds"],
+        handler: () => {
+          count.value += 1;
+        },
+      });
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(TestApp);
+    expect(app.loop.called).toBe(0);
+    expect(count.value).toBe(0);
+
+    await alepha.start();
+    expect(app.loop.called).toBe(1);
+    expect(count.value).toBe(1);
+
+    await alepha.stop();
+    expect(app.loop.called).toBe(1);
+    expect(count.value).toBe(1);
+  });
+});
+
+describe("Alepha start lifecycle", () => {
+  it("should track started and locked flags correctly", async () => {
+    const app = Alepha.create({});
+    const dt = app.inject(DateTimeProvider);
+
+    expect(app.isStarted()).toBe(false);
+    expect(app.isConfigured()).toBe(false);
+    expect(app.isLocked()).toBe(false);
+
+    const blocker = {
+      resolve: () => {},
+    };
+
+    const end = new Promise<void>((resolve) => {
+      blocker.resolve = resolve;
+    });
+
+    class LongStart {
+      _ = $hook({
+        on: "start",
+        handler: async () => {
+          blocker.resolve();
+          await dt.wait([1, "minute"]);
+        },
+      });
+    }
+
+    const startEnd = app.with(LongStart).start();
+
+    await end;
+
+    expect(app.isLocked()).toBe(true);
+    expect(app.isStarted()).toBe(false);
+
+    await dt.travel([1, "minute"]);
+    await startEnd;
+
+    expect(app.isStarted()).toBe(true);
+    expect(app.isLocked()).toBe(true);
+  });
+});

package/src/datetime/providers/DateTimeProvider.spec.ts

@@ -0,0 +1,86 @@
+import { Alepha } from "alepha";
+import { describe, expect, it } from "vitest";
+import { DateTimeProvider } from "../index.ts";
+
+describe("DateTimeProvider", () => {
+  it("should pause time and reset", async () => {
+    const app = Alepha.create();
+    const dt = app.inject(DateTimeProvider);
+    const clock = () => dt.nowISOString();
+
+    const n1 = clock();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    dt.pause();
+    const n2 = clock();
+
+    expect(n1).not.toBe(n2);
+    expect(n2).toBe(clock());
+    expect(n2).toBe(clock());
+    expect(n2).toBe(clock());
+
+    dt.reset();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(n2).not.toBe(clock());
+  });
+
+  it("should time travel and trigger scheduled callbacks", async () => {
+    const stack: string[] = [];
+    const app = Alepha.create();
+    const dt = app.inject(DateTimeProvider);
+
+    stack.push("A");
+
+    dt.wait([10, "minutes"]).then(() => stack.push("B"));
+    dt.wait([20, "minutes"]).then(() => stack.push("C"));
+
+    expect(stack).toEqual(["A"]);
+
+    await dt.travel([5, "minutes"]);
+
+    expect(stack).toEqual(["A"]);
+
+    await dt.travel([30, "minutes"]);
+
+    expect(stack).toEqual(["A", "B", "C"]);
+  });
+
+  it("should handle timeouts with clearTimeout", async () => {
+    const app = Alepha.create();
+    const dt = app.inject(DateTimeProvider);
+    const stack: string[] = [];
+
+    dt.createTimeout(() => stack.push("A"), [10, "minutes"]);
+    const n2 = dt.createTimeout(() => stack.push("B"), [10, "minutes"]);
+
+    expect(stack).toEqual([]);
+
+    await dt.travel([5, "minutes"]);
+    expect(stack).toEqual([]);
+
+    dt.clearTimeout(n2);
+
+    await dt.travel([5, "minutes"]);
+    expect(stack).toEqual(["A"]);
+  });
+
+  it("should wait with abort signal support", async () => {
+    const app = Alepha.create();
+    const dt = app.inject(DateTimeProvider);
+    const stack: string[] = [];
+
+    const abortController = new AbortController();
+    dt.wait([10, "minutes"], { signal: abortController.signal }).then(() =>
+      stack.push("A"),
+    );
+
+    expect(stack).toEqual([]);
+
+    abortController.abort();
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(stack).toEqual(["A"]);
+  });
+});

package/src/email/primitives/$email.spec.ts

@@ -0,0 +1,175 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import { $email, MemoryEmailProvider } from "../index.ts";
+
+describe("$email", () => {
+  test("should send email using primitive", async ({ expect }) => {
+    class TestService {
+      readonly welcomeEmail = $email({ name: "welcome" });
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.welcomeEmail.send({
+      to: "test@example.com",
+      subject: "Welcome!",
+      body: "<p>Hello World!</p>",
+    });
+
+    const provider = alepha.inject(MemoryEmailProvider);
+    const emails = provider.records;
+
+    expect(emails).toHaveLength(1);
+    expect(emails[0].to).toBe("test@example.com");
+    expect(emails[0].subject).toBe("Welcome!");
+    expect(emails[0].body).toBe("<p>Hello World!</p>");
+  });
+
+  test("should send email to multiple recipients", async ({ expect }) => {
+    class TestService {
+      readonly notificationEmail = $email();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.notificationEmail.send({
+      to: ["user1@example.com", "user2@example.com"],
+      subject: "Notification",
+      body: "<p>Important message</p>",
+    });
+
+    const provider = alepha.inject(MemoryEmailProvider);
+    const emails = provider.records;
+
+    expect(emails).toHaveLength(2);
+    expect(emails[0].to).toBe("user1@example.com");
+    expect(emails[1].to).toBe("user2@example.com");
+  });
+
+  test("should use memory provider by default", async ({ expect }) => {
+    class TestService {
+      readonly email = $email();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.email.send({
+      to: "test@example.com",
+      subject: "Test",
+      body: "Test",
+    });
+
+    const provider = alepha.inject(MemoryEmailProvider);
+    expect(provider.records).toHaveLength(1);
+  });
+
+  test("should use explicit memory provider", async ({ expect }) => {
+    class TestService {
+      readonly email = $email({ provider: "memory" });
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.email.send({
+      to: "test@example.com",
+      subject: "Test",
+      body: "Test",
+    });
+
+    const provider = alepha.inject(MemoryEmailProvider);
+    expect(provider.records).toHaveLength(1);
+  });
+
+  test("should emit email:sending and email:sent events", async ({
+    expect,
+  }) => {
+    class TestService {
+      readonly email = $email({ name: "test-email" });
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+
+    const sendingEvents: any[] = [];
+    const sentEvents: any[] = [];
+
+    alepha.events.on("email:sending", (event) => {
+      sendingEvents.push(event);
+    });
+
+    alepha.events.on("email:sent", (event) => {
+      sentEvents.push(event);
+    });
+
+    await alepha.start();
+
+    await service.email.send({
+      to: "test@example.com",
+      subject: "Test",
+      body: "Test body",
+    });
+
+    expect(sendingEvents).toHaveLength(1);
+    expect(sendingEvents[0].to).toBe("test@example.com");
+    expect(sendingEvents[0].template).toBe("test-email");
+
+    expect(sentEvents).toHaveLength(1);
+    expect(sentEvents[0].to).toBe("test@example.com");
+    expect(sentEvents[0].template).toBe("test-email");
+  });
+
+  test("should abort email sending via hook", async ({ expect }) => {
+    class TestService {
+      readonly email = $email();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+
+    alepha.events.on("email:sending", (event) => {
+      event.abort();
+    });
+
+    await alepha.start();
+
+    await expect(
+      service.email.send({
+        to: "test@example.com",
+        subject: "Test",
+        body: "Test",
+      }),
+    ).rejects.toThrowError("Email sending aborted by hook");
+  });
+
+  test("should use property key as default name", async ({ expect }) => {
+    class TestService {
+      readonly welcomeEmail = $email();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+
+    let capturedTemplate = "";
+    alepha.events.on("email:sending", (event) => {
+      capturedTemplate = event.template;
+    });
+
+    await alepha.start();
+
+    await service.welcomeEmail.send({
+      to: "test@example.com",
+      subject: "Test",
+      body: "Test",
+    });
+
+    expect(capturedTemplate).toBe("welcomeEmail");
+  });
+});