alepha 0.14.2 → 0.14.3

package/src/sms/providers/MemorySmsProvider.spec.ts

@@ -0,0 +1,193 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import { $sms, MemorySmsProvider, SmsProvider } from "../index.ts";
+
+describe("MemorySmsProvider", () => {
+  test("should store SMS in memory", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    await service.sms.send({
+      to: "+1234567890",
+      message: "Hello World!",
+    });
+
+    expect(provider.records).toHaveLength(1);
+    expect(provider.records[0].to).toBe("+1234567890");
+    expect(provider.records[0].message).toBe("Hello World!");
+    expect(provider.records[0].sentAt).toBeInstanceOf(Date);
+  });
+
+  test("should handle multiple recipients", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    await service.sms.send({
+      to: ["+1111111111", "+2222222222", "+3333333333"],
+      message: "Broadcast message",
+    });
+
+    expect(provider.records).toHaveLength(3);
+    expect(provider.records[0].to).toBe("+1111111111");
+    expect(provider.records[1].to).toBe("+2222222222");
+    expect(provider.records[2].to).toBe("+3333333333");
+    expect(
+      provider.records.every((r) => r.message === "Broadcast message"),
+    ).toBe(true);
+  });
+
+  test("should return last SMS sent", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    await service.sms.send({
+      to: "+1234567890",
+      message: "First message",
+    });
+
+    await service.sms.send({
+      to: "+0987654321",
+      message: "Second message",
+    });
+
+    expect(provider.last).toBeDefined();
+    expect(provider.last?.to).toBe("+0987654321");
+    expect(provider.last?.message).toBe("Second message");
+  });
+
+  test("should return undefined for last when no messages", async ({
+    expect,
+  }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    expect(provider.last).toBeUndefined();
+  });
+
+  test("should be registered as default SmsProvider", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(SmsProvider);
+
+    expect(provider).toBeInstanceOf(MemorySmsProvider);
+  });
+
+  test("should accumulate messages across multiple sends", async ({
+    expect,
+  }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    await service.sms.send({ to: "+1111111111", message: "Message 1" });
+    await service.sms.send({ to: "+2222222222", message: "Message 2" });
+    await service.sms.send({ to: "+3333333333", message: "Message 3" });
+
+    expect(provider.records).toHaveLength(3);
+    expect(provider.records.map((r) => r.message)).toEqual([
+      "Message 1",
+      "Message 2",
+      "Message 3",
+    ]);
+  });
+
+  test("should track sentAt timestamp for each message", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    const before = new Date();
+    await service.sms.send({ to: "+1234567890", message: "Test" });
+    const after = new Date();
+
+    const sentAt = provider.records[0].sentAt;
+    expect(sentAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
+    expect(sentAt.getTime()).toBeLessThanOrEqual(after.getTime());
+  });
+
+  test("should handle empty message", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    await service.sms.send({
+      to: "+1234567890",
+      message: "",
+    });
+
+    expect(provider.records).toHaveLength(1);
+    expect(provider.records[0].message).toBe("");
+  });
+
+  test("should handle message with special characters", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    const provider = alepha.inject(MemorySmsProvider);
+
+    const specialMessage = "Hello! 🎉 Special chars: <>&\"'";
+    await service.sms.send({
+      to: "+1234567890",
+      message: specialMessage,
+    });
+
+    expect(provider.records[0].message).toBe(specialMessage);
+  });
+});

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

@@ -0,0 +1,186 @@
+import { Alepha, t } from "alepha";
+import { afterEach, beforeEach, describe, it } from "vitest";
+import { $thread, AlephaThread, ThreadPrimitive } from "../index.ts";
+
+class TestApp {
+  testThread = $thread({
+    name: "test-thread",
+    handler: async () => {
+      return { message: "Hello from thread!", timestamp: Date.now() };
+    },
+  });
+}
+
+describe("$thread", () => {
+  let threadPrimitive: ThreadPrimitive;
+  let alepha: Alepha;
+
+  beforeEach(async () => {
+    alepha = Alepha.create().with(AlephaThread).with(TestApp);
+    threadPrimitive = alepha.inject(TestApp).testThread;
+  });
+
+  afterEach(async () => {
+    if (threadPrimitive) {
+      await threadPrimitive.terminate();
+    }
+    if (alepha) {
+      await alepha.stop();
+    }
+  });
+
+  it("should create a thread primitive", ({ expect }) => {
+    expect($thread).toBeDefined();
+    expect(threadPrimitive).toBeInstanceOf(ThreadPrimitive);
+    expect(threadPrimitive.name).toBe("test-thread");
+  });
+
+  it("should have correct default configuration", async ({ expect }) => {
+    class DefaultTestApp {
+      defaultThread = $thread({
+        handler: async () => "test",
+      });
+    }
+
+    const testAlepha = Alepha.create().with(AlephaThread).with(DefaultTestApp);
+    const defaultThread = testAlepha.inject(DefaultTestApp).defaultThread;
+
+    expect(defaultThread.maxPoolSize).toBeGreaterThan(0);
+    expect(defaultThread.idleTimeout).toBe(60000); // 1 minute
+
+    await testAlepha.stop();
+  });
+
+  it("should allow custom pool size and idle timeout", async ({ expect }) => {
+    class CustomTestApp {
+      customThread = $thread({
+        name: "custom-thread",
+        handler: async () => "test",
+        maxPoolSize: 4,
+        idleTimeout: 30000,
+      });
+    }
+
+    const testAlepha = Alepha.create().with(AlephaThread).with(CustomTestApp);
+    const customThread = testAlepha.inject(CustomTestApp).customThread;
+
+    expect(customThread.maxPoolSize).toBe(4);
+    expect(customThread.idleTimeout).toBe(30000);
+
+    await testAlepha.stop();
+  });
+
+  it("should validate data with TypeBox schema", async ({ expect }) => {
+    const schema = t.object({
+      name: t.text(),
+      age: t.number(),
+    });
+
+    // Invalid data should throw validation error
+    await expect(
+      threadPrimitive.execute({ name: "John" }, schema),
+    ).rejects.toThrow("Invalid data");
+  });
+
+  it("should warm up thread pool", async ({ expect }) => {
+    await expect(threadPrimitive.create()).resolves.toBeUndefined();
+  });
+
+  it("should terminate thread pool", async ({ expect }) => {
+    await threadPrimitive.create();
+    await expect(threadPrimitive.terminate()).resolves.toBeUndefined();
+  });
+});
+
+describe("Thread primitive configuration", () => {
+  let testAlepha: Alepha;
+
+  beforeEach(async () => {
+    testAlepha = Alepha.create().with(AlephaThread);
+  });
+
+  afterEach(async () => {
+    if (testAlepha) {
+      await testAlepha.stop();
+    }
+  });
+
+  it("should handle different configuration options", async ({ expect }) => {
+    class ConfigTestApp {
+      defaultThread = $thread({
+        handler: async () => "default",
+      });
+
+      namedThread = $thread({
+        name: "custom-name",
+        handler: async () => "named",
+      });
+
+      configuredThread = $thread({
+        name: "configured",
+        handler: async () => "configured",
+        maxPoolSize: 8,
+        idleTimeout: 120000,
+      });
+    }
+
+    testAlepha = testAlepha.with(ConfigTestApp);
+    const app = testAlepha.inject(ConfigTestApp);
+
+    // Test default configuration
+    expect(app.defaultThread.maxPoolSize).toBeGreaterThan(0);
+    expect(app.defaultThread.idleTimeout).toBe(60000);
+
+    // Test named thread
+    expect(app.namedThread.name).toBe("custom-name");
+
+    // Test configured thread
+    expect(app.configuredThread.name).toBe("configured");
+    expect(app.configuredThread.maxPoolSize).toBe(8);
+    expect(app.configuredThread.idleTimeout).toBe(120000);
+  });
+});
+
+describe("Thread pool management", () => {
+  let testAlepha: Alepha;
+
+  beforeEach(async () => {
+    testAlepha = Alepha.create().with(AlephaThread);
+  });
+
+  afterEach(async () => {
+    if (testAlepha) {
+      await testAlepha.stop();
+    }
+  });
+
+  it("should have consistent pool instances", async ({ expect }) => {
+    class PoolTestApp {
+      thread1 = $thread({
+        name: "shared-pool",
+        handler: async () => "thread1",
+      });
+
+      thread2 = $thread({
+        name: "shared-pool", // Same name = shared pool
+        handler: async () => "thread2",
+      });
+
+      thread3 = $thread({
+        name: "different-pool",
+        handler: async () => "thread3",
+      });
+    }
+
+    testAlepha = testAlepha.with(PoolTestApp);
+    const app = testAlepha.inject(PoolTestApp);
+
+    // Threads with same name should share configuration
+    expect(app.thread1.name).toBe(app.thread2.name);
+    expect(app.thread3.name).not.toBe(app.thread1.name);
+
+    // Clean up
+    await app.thread1.terminate();
+    await app.thread3.terminate();
+  });
+});

package/src/topic/core/__tests__/shared.ts

@@ -0,0 +1,144 @@
+import { $inject, Alepha, type Service, t } from "alepha";
+import {
+  $subscriber,
+  $topic,
+  AlephaTopic,
+  MemoryTopicProvider,
+  type SubscribeCallback,
+  TopicProvider,
+} from "alepha/topic";
+import { expect } from "vitest";
+
+export const payloadSchema = t.object({
+  id: t.text(),
+  count: t.integer(),
+});
+
+export const subscriptions: Record<string, SubscribeCallback[]> = {};
+export class SharedTopicProvider extends MemoryTopicProvider {
+  subscriptions = subscriptions;
+}
+
+export const testTopicBasic = async (provider: Service<TopicProvider>) => {
+  class TestTopic {
+    t = $topic({
+      name: "test",
+      schema: {
+        payload: payloadSchema,
+      },
+    });
+  }
+
+  class TestSubscriber {
+    stack: string[] = [];
+    test = $inject(TestTopic);
+    s = $subscriber({
+      topic: this.test.t,
+      handler: async (m) => {
+        this.stack.push(m.payload.id + m.payload.count);
+      },
+    });
+  }
+
+  const createApp = async <T extends object>(
+    testClass: Service<T>,
+  ): Promise<{ app: Alepha; test: T }> => {
+    const app = Alepha.create();
+
+    app.with({
+      provide: TopicProvider,
+      use: provider,
+    });
+
+    const test = app.inject(testClass);
+
+    await app.start();
+
+    return { app, test };
+  };
+
+  const { app: app1, test: test1 } = await createApp(TestTopic);
+  const { app: app2, test: test2 } = await createApp(TestTopic);
+  const { app: app3, test: test3 } = await createApp(TestSubscriber);
+  const { app: app4, test: test4 } = await createApp(TestSubscriber);
+
+  await test1.t.publish({ id: "1", count: 2 });
+  await test2.t.publish({ id: "2", count: 3 });
+
+  await Promise.all([
+    expect.poll(() => expect(test3.stack).toEqual(["12", "23"])).toBeTruthy(),
+    expect.poll(() => expect(test4.stack).toEqual(["12", "23"])).toBeTruthy(),
+  ]);
+
+  await app1.stop();
+  await app2.stop();
+  await app3.stop();
+  await app4.stop();
+};
+
+export const testTopicAsSub = async (provider: Service<TopicProvider>) => {
+  let count = 0;
+  class A {
+    t = $topic({
+      name: "a",
+      schema: {
+        payload: t.object({ n: t.integer() }),
+      },
+      handler: async ({ payload }) => {
+        count += payload.n;
+      },
+    });
+  }
+
+  const app = Alepha.create({})
+    .with({
+      provide: TopicProvider,
+      use: provider,
+    })
+    .with(A);
+
+  await app.start();
+
+  const a = app.inject(A);
+
+  await a.t.publish({ n: 123 });
+
+  await expect.poll(() => expect(count).toBe(123)).toBeTruthy();
+  //await expect(a.t.publish({ n: 123.6 })).rejects.toThrowError(TypeBoxError);
+};
+
+export const testTopicLateSubscribe = async (
+  Provider: Service<TopicProvider>,
+) => {
+  const alepha = Alepha.create()
+    .with({
+      provide: TopicProvider,
+      use: Provider,
+    })
+    .with(AlephaTopic);
+
+  await alepha.start();
+
+  const provider = alepha.inject(TopicProvider);
+
+  // no topic created yet !
+
+  let count = 0;
+  const unsub = await provider.subscribe("inc", () => {
+    count += 1;
+  });
+  await provider.subscribe("inc10", () => {
+    count += 10;
+  });
+
+  expect(count).toBe(0);
+  await provider.publish("inc", "");
+  await provider.publish("inc10", "");
+  await expect.poll(() => expect(count).toBe(11)).toBeTruthy();
+
+  await unsub();
+
+  await provider.publish("inc", "");
+  await provider.publish("inc10", "");
+  await expect.poll(() => expect(count).toBe(21)).toBeTruthy();
+};

package/src/topic/core/providers/MemoryTopicProvider.spec.ts

@@ -0,0 +1,23 @@
+import { describe, test } from "vitest";
+import {
+  SharedTopicProvider,
+  testTopicAsSub,
+  testTopicBasic,
+  testTopicLateSubscribe,
+} from "../__tests__/shared.ts";
+
+describe("$topic - memory", () => {
+  const provider = SharedTopicProvider;
+
+  test("should subscribe and publish", async () => {
+    await testTopicBasic(provider);
+  });
+
+  test("should subscribe with handler", async () => {
+    await testTopicAsSub(provider);
+  });
+
+  test("should subscribe after start with provider", async () => {
+    await testTopicLateSubscribe(provider);
+  });
+});

package/src/topic/redis/providers/RedisTopicProvider.spec.ts

@@ -0,0 +1,23 @@
+import { describe, test } from "vitest";
+import {
+  testTopicAsSub,
+  testTopicBasic,
+  testTopicLateSubscribe,
+} from "../../core/__tests__/shared.ts";
+import { RedisTopicProvider } from "../index.ts";
+
+describe("$topic - redis", () => {
+  const provider = RedisTopicProvider;
+
+  test("should subscribe and publish", async () => {
+    await testTopicBasic(provider);
+  });
+
+  test("should subscribe with handler", async () => {
+    await testTopicAsSub(provider);
+  });
+
+  test("should subscribe after start with provider", async () => {
+    await testTopicLateSubscribe(provider);
+  });
+});

package/src/vite/plugins/viteAlephaDev.ts

@@ -1,3 +1,4 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
 import type { Plugin, ResolvedConfig } from "vite";
 import { boot } from "../helpers/boot.ts";
 import { createAlephaRunner, isViteInternalPath } from "../tasks/runAlepha.ts";
@@ -102,8 +103,11 @@ export async function viteAlephaDev(
       }
     },
     async configureServer(server) {
-      // Forward vite request to alepha server
-      server.middlewares.use((req, res, next) => {
+      const middleware = (
+        req: IncomingMessage,
+        res: ServerResponse,
+        next: any,
+      ) => {
         if (
           runner.isStarted &&
           runner.app &&
@@ -129,6 +133,12 @@ export async function viteAlephaDev(
             });
         }
         next();
+      };
+
+      // Forward vite request to alepha server
+      server.middlewares.use((req, res, next) => {
+        // TODO: wait if restarting ?
+        middleware(req, res, next);
       });
 
       server.config.logger.info = (msg: string) => {
@@ -139,8 +149,10 @@ export async function viteAlephaDev(
 
       // Return a function - it runs AFTER internal middlewares are set up
       // and after buildStart has been called
-      return async () => {
-        await runner.start(server);
+      return () => {
+        server.httpServer?.once("listening", () => {
+          runner.start(server);
+        });
       };
     },
     async closeBundle() {

package/src/vite/tasks/runAlepha.ts

@@ -132,13 +132,19 @@ export class AlephaRunner {
       process.env[key] = env[key];
     }
 
+    let port = 5173;
+    const address = server.httpServer?.address();
+    if (typeof address === "object" && address?.port) {
+      port = address.port;
+    }
+
     process.env.NODE_ENV ??= "development";
     process.env.VITE_ALEPHA_DEV = "true";
     process.env.SERVER_HOST ??=
       typeof server.config.server.host === "string"
         ? server.config.server.host
         : "localhost";
-    process.env.SERVER_PORT ??= String(server.config.server.port || "5173");
+    process.env.SERVER_PORT ??= String(port);
 
     try {
       const now = Date.now();