alepha 0.14.2 → 0.14.4

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

@@ -0,0 +1,143 @@
+import { $inject, Alepha, type Service, t } from "alepha";
+import {
+  $consumer,
+  $queue,
+  MemoryQueueProvider,
+  QueueProvider,
+  WorkerProvider,
+} from "alepha/queue";
+import { expect } from "vitest";
+
+export const payloadSchema = t.object({
+  id: t.text(),
+  count: t.integer(),
+});
+
+export const queueList: Record<string, string[]> = {};
+export class SharedQueueProvider extends MemoryQueueProvider {
+  queueList = queueList;
+}
+
+export const testQueueBasic = async (provider: Service<QueueProvider>) => {
+  class TestQueue {
+    q = $queue({
+      name: "test",
+      schema: payloadSchema,
+    });
+  }
+
+  class TestConsumer {
+    stack: string[] = [];
+    test = $inject(TestQueue);
+    s = $consumer({
+      queue: this.test.q,
+      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({
+      env: {
+        QUEUE_WORKER_INTERVAL: 10,
+      },
+    });
+
+    app.with({
+      provide: QueueProvider,
+      use: provider,
+    });
+
+    const test = app.inject(testClass);
+
+    await app.start();
+
+    return { app, test };
+  };
+
+  const { app: app1, test: test1 } = await createApp(TestQueue);
+  const { app: app2, test: test2 } = await createApp(TestQueue);
+  const { app: app3, test: test3 } = await createApp(TestConsumer);
+
+  await test1.q.push({ id: "1", count: 2 });
+  await test2.q.push({ id: "2", count: 3 });
+
+  await expect
+    .poll(() => expect(test3.stack).toEqual(["12", "23"]))
+    .toBeTruthy();
+
+  await app1.stop();
+  await app2.stop();
+  await app3.stop();
+};
+
+export const testQueueHasConsumer = async (
+  provider: Service<QueueProvider>,
+) => {
+  let count = 0;
+  class A {
+    q = $queue({
+      schema: t.object({ n: t.integer() }),
+      handler: async ({ payload }) => {
+        count += payload.n;
+      },
+    });
+  }
+  const app = Alepha.create()
+    .with({
+      provide: QueueProvider,
+      use: provider,
+    })
+    .with(A);
+
+  await app.start();
+  expect(count).toBe(0);
+
+  await app.inject(A).q.push({ n: 123 });
+  await expect.poll(() => expect(count).toBe(123)).toBeTruthy();
+};
+
+export const testQueueKillWorkerSleep = async (
+  provider: Service<QueueProvider>,
+) => {
+  let count = 0;
+  class A {
+    q = $queue({
+      schema: t.object({}),
+    });
+    c = $consumer({
+      queue: this.q,
+      handler: async () => {},
+    });
+  }
+
+  const app = Alepha.create({
+    env: {
+      QUEUE_WORKER_INTERVAL: 10000,
+    },
+  })
+    .with({
+      provide: QueueProvider,
+      use: provider,
+    })
+    .with({
+      provide: WorkerProvider,
+      use: class FakeQueueDescriptorProvider extends WorkerProvider {
+        async stopWorkers() {
+          await super.stopWorkers();
+          count += 123;
+        }
+      },
+    })
+    .with(A);
+
+  expect(count).toBe(0);
+  await app.start();
+  expect(count).toBe(0);
+
+  await app.stop();
+  expect(count).toBe(123);
+};

package/src/queue/core/providers/MemoryQueueProvider.spec.ts

@@ -0,0 +1,23 @@
+import { describe, test } from "vitest";
+import {
+  SharedQueueProvider,
+  testQueueBasic,
+  testQueueHasConsumer,
+  testQueueKillWorkerSleep,
+} from "../__tests__/shared.ts";
+
+describe("MemoryQueueProvider", () => {
+  const Provider = SharedQueueProvider;
+
+  test("should push and pop with consumer", async () => {
+    await testQueueBasic(Provider);
+  });
+
+  test("should push and pop with handler", async () => {
+    await testQueueHasConsumer(Provider);
+  });
+
+  test("should wake up workers on push", async () => {
+    await testQueueKillWorkerSleep(Provider);
+  });
+});

package/src/queue/core/providers/WorkerProvider.spec.ts

@@ -0,0 +1,394 @@
+import { Alepha, t } from "alepha";
+import { $logger } from "alepha/logger";
+import { describe, expect, test, vi } from "vitest";
+import {
+  $consumer,
+  $queue,
+  MemoryQueueProvider,
+  QueueProvider,
+  WorkerProvider,
+} from "../index.ts";
+
+const payloadSchema = t.object({
+  id: t.text(),
+  count: t.integer(),
+});
+
+class TestWorkerProvider extends WorkerProvider {
+  public readonly log = $logger();
+  public workersRunning = 0;
+  public workerIntervals: Record<number, number> = {};
+  public abortController = new AbortController();
+  public waitForNextMessage(n: number): Promise<void> {
+    return super.waitForNextMessage(n);
+  }
+}
+
+describe("WorkerProvider", () => {
+  const createTestApp = async (
+    options: {
+      workerConcurrency?: number;
+      workerInterval?: number;
+      workerMaxInterval?: number;
+    } = {},
+  ) => {
+    const app = Alepha.create({
+      env: {
+        QUEUE_WORKER_CONCURRENCY: options.workerConcurrency ?? 1,
+        QUEUE_WORKER_INTERVAL: options.workerInterval ?? 10,
+        QUEUE_WORKER_MAX_INTERVAL: options.workerMaxInterval ?? 1000,
+      },
+    });
+
+    app.with({
+      provide: WorkerProvider,
+      use: TestWorkerProvider,
+    });
+
+    app.with({
+      provide: QueueProvider,
+      use: MemoryQueueProvider,
+    });
+
+    return app;
+  };
+
+  describe("Worker Lifecycle", () => {
+    test("should start workers when consumers are present", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {
+            // Just a dummy handler for this test
+          },
+        });
+      }
+
+      const app = await createTestApp();
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const logSpy = vi.spyOn(workerProvider.log, "debug");
+
+      await app.start();
+
+      expect(logSpy).toHaveBeenCalledWith("Starting worker n-0");
+      expect(workerProvider.workersRunning).toBe(1);
+
+      await app.stop();
+      expect(workerProvider.workersRunning).toBe(0);
+    });
+
+    test("should start multiple workers with concurrency", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {},
+        });
+      }
+
+      const app = await createTestApp({ workerConcurrency: 3 });
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const logSpy = vi.spyOn(workerProvider.log, "debug");
+
+      await app.start();
+
+      expect(logSpy).toHaveBeenCalledWith("Starting worker n-0");
+      expect(logSpy).toHaveBeenCalledWith("Starting worker n-1");
+      expect(logSpy).toHaveBeenCalledWith("Starting worker n-2");
+      expect(workerProvider.workersRunning).toBe(3);
+
+      await app.stop();
+      expect(workerProvider.workersRunning).toBe(0);
+    });
+
+    test("should not start workers when no consumers", async () => {
+      const app = await createTestApp();
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const logSpy = vi.spyOn(workerProvider.log, "debug");
+
+      await app.start();
+
+      expect(logSpy).not.toHaveBeenCalledWith(
+        expect.stringMatching(/Starting worker/),
+      );
+      expect(workerProvider.workersRunning).toBe(0);
+
+      await app.stop();
+    });
+  });
+
+  describe("WakeUp Functionality", () => {
+    test("should wake up workers and start missing ones", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {},
+        });
+      }
+
+      const app = await createTestApp({ workerConcurrency: 2 });
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const debugSpy = vi.spyOn(workerProvider.log, "debug");
+
+      await app.start();
+      expect(workerProvider.workersRunning).toBe(2);
+
+      // Simulate worker crash by manually decrementing counter
+      workerProvider.workersRunning = 1;
+
+      // Call wakeUp - should detect missing worker and restart it
+      workerProvider.wakeUp();
+
+      expect(debugSpy).toHaveBeenCalledWith("Waking up workers...");
+      expect(workerProvider.workersRunning).toBe(2);
+
+      await app.stop();
+    });
+
+    test("should create new AbortController on wakeUp", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {},
+        });
+      }
+
+      const app = await createTestApp();
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+
+      await app.start();
+
+      const oldController = workerProvider.abortController;
+      expect(oldController.signal.aborted).toBe(false);
+
+      workerProvider.wakeUp();
+
+      const newController = workerProvider.abortController;
+      expect(oldController.signal.aborted).toBe(true);
+      expect(newController.signal.aborted).toBe(false);
+      expect(newController).not.toBe(oldController);
+
+      await app.stop();
+    });
+  });
+
+  describe("Message Processing", () => {
+    test("should process messages correctly", async () => {
+      const messages: any[] = [];
+
+      class TestService {
+        queue = $queue({
+          schema: payloadSchema,
+          handler: async ({ payload }) => {
+            messages.push(payload);
+          },
+        });
+      }
+
+      const app = await createTestApp({ workerInterval: 5 });
+      app.with(TestService);
+
+      await app.start();
+
+      const testService = app.inject(TestService);
+      await testService.queue.push({ id: "msg1", count: 5 });
+      await testService.queue.push({ id: "msg2", count: 10 });
+
+      await expect
+        .poll(() => messages.length === 2, { timeout: 1000 })
+        .toBeTruthy();
+      expect(messages).toEqual([
+        { id: "msg1", count: 5 },
+        { id: "msg2", count: 10 },
+      ]);
+
+      await app.stop();
+    });
+
+    test("should handle message processing errors gracefully", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async ({ payload }) => {
+            if (payload.id === "error") {
+              throw new Error("Processing error");
+            }
+          },
+        });
+      }
+
+      const app = await createTestApp();
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const errorSpy = vi.spyOn(workerProvider.log, "error");
+
+      await app.start();
+
+      const testService = app.inject(TestService);
+      await testService.queue.push({ id: "error", count: 1 });
+
+      await expect
+        .poll(() => errorSpy.mock.calls.length > 0, { timeout: 500 })
+        .toBeTruthy();
+
+      // Worker should still be running after processing error
+      expect(workerProvider.workersRunning).toBe(1);
+
+      await app.stop();
+    });
+
+    test("should handle consumer with queue descriptor", async () => {
+      const messages: any[] = [];
+
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+        });
+
+        consumer = $consumer({
+          queue: this.queue,
+          handler: async ({ payload }) => {
+            messages.push(payload);
+          },
+        });
+      }
+
+      const app = await createTestApp();
+      app.with(TestService);
+
+      await app.start();
+
+      const testService = app.inject(TestService);
+      await testService.queue.push({ id: "consumer-test", count: 15 });
+
+      await expect
+        .poll(() => messages.length === 1, { timeout: 500 })
+        .toBeTruthy();
+      expect(messages).toEqual([{ id: "consumer-test", count: 15 }]);
+
+      await app.stop();
+    });
+  });
+
+  describe("Edge Cases", () => {
+    test("should handle malformed JSON messages", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {},
+        });
+      }
+
+      const app = await createTestApp();
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const queueProvider = app.inject(QueueProvider);
+      const errorSpy = vi.spyOn(workerProvider.log, "error");
+
+      await app.start();
+
+      // Push malformed JSON directly to the queue
+      await queueProvider.push("test", "invalid-json");
+
+      await expect
+        .poll(() => errorSpy.mock.calls.length > 0, { timeout: 500 })
+        .toBeTruthy();
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Failed to process message",
+        expect.any(Error),
+      );
+
+      // Worker should still be running
+      expect(workerProvider.workersRunning).toBe(1);
+
+      await app.stop();
+    });
+
+    test("should handle schema validation errors", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {},
+        });
+      }
+
+      const app = await createTestApp();
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const queueProvider = app.inject(QueueProvider);
+      const errorSpy = vi.spyOn(workerProvider.log, "error");
+
+      await app.start();
+
+      // Push message with invalid schema
+      await queueProvider.push(
+        "test",
+        JSON.stringify({
+          payload: { id: 123, count: "invalid" }, // id should be string, count should be number
+        }),
+      );
+
+      await expect
+        .poll(() => errorSpy.mock.calls.length > 0, { timeout: 500 })
+        .toBeTruthy();
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Failed to process message",
+        expect.any(Error),
+      );
+
+      // Worker should still be running
+      expect(workerProvider.workersRunning).toBe(1);
+
+      await app.stop();
+    });
+
+    test("should handle abort signal during wait", async () => {
+      class TestService {
+        queue = $queue({
+          name: "test",
+          schema: payloadSchema,
+          handler: async () => {},
+        });
+      }
+
+      const app = await createTestApp({ workerInterval: 5000 });
+      app.with(TestService);
+
+      const workerProvider = app.inject(TestWorkerProvider);
+      const warnSpy = vi.spyOn(workerProvider.log, "warn");
+
+      await app.start();
+
+      // Abort the controller to simulate abort during wait
+      workerProvider.abortController.abort();
+
+      // This should detect the abort and return early
+      await workerProvider.waitForNextMessage(0);
+
+      expect(warnSpy).toHaveBeenCalledWith("Worker n-0 aborted.");
+
+      await app.stop();
+    });
+  });
+});

package/src/queue/redis/providers/RedisQueueProvider.spec.ts

@@ -0,0 +1,23 @@
+import { describe, test } from "vitest";
+import {
+  testQueueBasic,
+  testQueueHasConsumer,
+  testQueueKillWorkerSleep,
+} from "../../core/__tests__/shared.ts";
+import { RedisQueueProvider } from "../index.ts";
+
+describe("RedisQueueProvider", () => {
+  const Provider = RedisQueueProvider;
+
+  test("should push and pop with consumer", async () => {
+    await testQueueBasic(Provider);
+  });
+
+  test("should push and pop with handler", async () => {
+    await testQueueHasConsumer(Provider);
+  });
+
+  test("should wake up workers on push", async () => {
+    await testQueueKillWorkerSleep(Provider);
+  });
+});

package/src/redis/__tests__/redis.spec.ts

@@ -0,0 +1,58 @@
+import { randomUUID } from "node:crypto";
+import { Alepha } from "alepha";
+import { describe, it } from "vitest";
+import {
+  AlephaRedis,
+  RedisProvider,
+  RedisSubscriberProvider,
+} from "../index.ts";
+
+const alepha = Alepha.create().with(AlephaRedis);
+const redis = alepha.inject(RedisProvider);
+const sub = alepha.inject(RedisSubscriberProvider);
+
+describe("Redis", () => {
+  it("should set and get values", async ({ expect }) => {
+    const uuid = randomUUID();
+    await redis.set("test", uuid);
+    const value = await redis.get("test");
+    expect(value?.toString()).toBe(uuid);
+  });
+
+  it("should support pub/sub messaging", async ({ expect }) => {
+    const stack: string[] = [];
+    await sub.subscribe("test", (message: string) => {
+      stack.push(message);
+    });
+    await redis.publish("test", "hello");
+    await expect.poll(() => stack.length).toBe(1);
+    expect(stack).toEqual(["hello"]);
+  });
+
+  it("should handle buffer values correctly", async ({ expect }) => {
+    const uuid = randomUUID().replace(/-/g, "");
+    await redis.set("test:string", uuid);
+    await redis.set("test:buffer", Buffer.from(uuid, "hex"));
+
+    const buf1 = await redis.get("test:string");
+    expect(buf1).toBeInstanceOf(Buffer);
+    expect(buf1?.byteLength).toBe(32);
+    expect(buf1?.toString("utf-8")).toBe(uuid);
+
+    const buf2 = await redis.get("test:buffer");
+    expect(buf2).toBeInstanceOf(Buffer);
+    expect(buf2?.byteLength).toBe(16);
+    expect(buf2?.toString("hex")).toBe(uuid);
+  });
+
+  it("should properly clean up connections on stop", async () => {
+    const alepha = Alepha.create().with(AlephaRedis);
+    const redis = alepha.inject(RedisProvider);
+    const sub = alepha.inject(RedisSubscriberProvider);
+    await alepha.start();
+    await sub.subscribe("test", (_message: string) => {});
+    await redis.publish("test:a", "a");
+    await redis.lpush("test:b", "b");
+    await alepha.stop();
+  });
+});