alepha 0.14.1 → 0.14.3

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

@@ -0,0 +1,190 @@
+import { randomUUID } from "node:crypto";
+import { $inject, Alepha, type Service } from "alepha";
+import { DateTimeProvider, type DurationLike } from "alepha/datetime";
+import {
+  $lock,
+  AlephaLock,
+  LockProvider,
+  LockTopicProvider,
+  MemoryLockProvider,
+} from "alepha/lock";
+import {
+  MemoryTopicProvider,
+  type SubscribeCallback,
+  type TopicProvider,
+} from "alepha/topic";
+import { expect } from "vitest";
+
+export const store: Record<string, string> = {};
+export class SharedLockProvider extends MemoryLockProvider {
+  store: Record<string, string> = store;
+}
+
+export const subscriptions: Record<string, SubscribeCallback[]> = {};
+export class SharedTopicProvider extends MemoryTopicProvider {
+  subscriptions: Record<string, SubscribeCallback[]> = subscriptions;
+}
+
+export const testLockBasic = async (
+  provider: Service<LockProvider>,
+  topicProvider: Service<TopicProvider>,
+): Promise<void> => {
+  const state: Record<string, string> = {};
+  class TestLock {
+    lock = $inject(LockProvider);
+    dt = $inject(DateTimeProvider);
+    stack = () => state.stack;
+    migrate = $lock({
+      handler: async () => {
+        await this.dt.wait([50, "milliseconds"]);
+        state.stack = state.stack ? `${state.stack}A` : "A";
+      },
+    });
+  }
+
+  const prefix = randomUUID();
+
+  const createApp = async () => {
+    return Alepha.create({
+      env: {
+        LOCK_PREFIX_KEY: prefix,
+      },
+    })
+      .with({
+        provide: LockTopicProvider,
+        use: topicProvider,
+      })
+      .with({
+        provide: LockProvider,
+        use: provider,
+      })
+      .with(AlephaLock)
+      .with(TestLock)
+      .start()
+      .then((a) => a.inject(TestLock));
+  };
+
+  const app1 = await createApp();
+  const app2 = await createApp();
+  const app3 = await createApp();
+
+  await app1.lock.set("stack", "");
+
+  await Promise.all([
+    app1.migrate.run(),
+    app2.migrate.run(),
+    app3.migrate.run(),
+  ]);
+
+  expect(app1.stack()).toBe("A");
+  expect(app2.stack()).toBe("A");
+  expect(app3.stack()).toBe("A");
+};
+
+export const testLockWait = async (
+  provider: Service<LockProvider>,
+  topicProvider: Service<TopicProvider>,
+): Promise<void> => {
+  let count = 0;
+
+  class TestLockWait {
+    dt = $inject(DateTimeProvider);
+
+    migrateLock = $lock({
+      wait: true,
+      handler: async () => {
+        count++;
+        await this.dt.wait([500, "milliseconds"]);
+      },
+    });
+
+    async migrate() {
+      const now = Date.now();
+      await this.migrateLock.run();
+      return Date.now() - now;
+    }
+  }
+
+  const createApp = async () => {
+    const app = Alepha.create()
+      .with({
+        provide: LockTopicProvider,
+        use: topicProvider,
+      })
+      .with({
+        provide: LockProvider,
+        use: provider,
+      });
+    app.with(TestLockWait);
+    return app.start().then(() => app.inject(TestLockWait));
+  };
+
+  const app1 = await createApp();
+  const app2 = await createApp();
+  const app3 = await createApp();
+
+  const result = await Promise.all([
+    app1.migrate(),
+    app2.migrate(),
+    app3.migrate(),
+  ]);
+
+  expect(result[0]).toBeGreaterThanOrEqual(500);
+  expect(result[1]).toBeGreaterThanOrEqual(500);
+  expect(result[2]).toBeGreaterThanOrEqual(500);
+
+  expect(count).toBe(1);
+};
+
+export const testLockGracePeriod = async (
+  provider: Service<LockProvider>,
+  topicProvider: Service<TopicProvider>,
+): Promise<void> => {
+  const config: {
+    gracePeriod?: DurationLike;
+  } = {};
+  let count = 0;
+
+  const createApp = () => {
+    const alepha = Alepha.create()
+      .with({
+        provide: LockTopicProvider,
+        use: topicProvider,
+      })
+      .with({
+        provide: LockProvider,
+        use: provider,
+      });
+
+    class TestApp {
+      fn = $lock({
+        gracePeriod: config.gracePeriod,
+        handler: async () => {
+          count += 1;
+        },
+      });
+    }
+    const fn = alepha.inject(TestApp).fn;
+    alepha.events.on("ready", () => fn.run());
+    return alepha;
+  };
+
+  // no grace period
+  // as you run apps one by one, lock is released after each start!
+  count = 0;
+  expect(count).toBe(0);
+  for (const app of [createApp(), createApp(), createApp()]) {
+    await app.start();
+  }
+  expect(count).toBe(3);
+
+  // but with grace period
+  // as we wait 1 second before releasing lock, all started apps will see the lock!
+  count = 0;
+  expect(count).toBe(0);
+  config.gracePeriod = [1, "seconds"];
+  for (const app of [createApp(), createApp(), createApp()]) {
+    await app.start();
+  }
+  expect(count).toBe(1);
+};

package/src/lock/core/providers/MemoryLockProvider.spec.ts

@@ -0,0 +1,25 @@
+import { describe, test } from "vitest";
+import {
+  SharedLockProvider,
+  SharedTopicProvider,
+  testLockBasic,
+  testLockGracePeriod,
+  testLockWait,
+} from "../__tests__/shared.ts";
+
+describe("MemoryLockProvider", () => {
+  const Provider = SharedLockProvider;
+  const TopicProvider = SharedTopicProvider;
+
+  test("should lock without waiting", async () => {
+    await testLockBasic(Provider, TopicProvider);
+  });
+
+  test("should lock and wait", async () => {
+    await testLockWait(Provider, TopicProvider);
+  });
+
+  test("should lock with grace period", async () => {
+    await testLockGracePeriod(Provider, TopicProvider);
+  });
+});

package/src/lock/redis/providers/RedisLockProvider.spec.ts

@@ -0,0 +1,25 @@
+import { RedisTopicProvider } from "alepha/topic/redis";
+import { describe, test } from "vitest";
+import {
+  testLockBasic,
+  testLockGracePeriod,
+  testLockWait,
+} from "../../core/__tests__/shared.ts";
+import { RedisLockProvider } from "../index.ts";
+
+describe("RedisLockProvider", () => {
+  const Provider = RedisLockProvider;
+  const TopicProvider = RedisTopicProvider;
+
+  test("should lock without waiting", async () => {
+    await testLockBasic(Provider, TopicProvider);
+  });
+
+  test("should lock with waiting", async () => {
+    await testLockWait(Provider, TopicProvider);
+  });
+
+  test("should lock with grace period", async () => {
+    await testLockGracePeriod(Provider, TopicProvider);
+  });
+});

package/src/logger/__tests__/SimpleFormatterProvider.spec.ts

@@ -0,0 +1,109 @@
+import { Alepha, AlephaError } from "alepha";
+import { describe, it } from "vitest";
+import {
+  $logger,
+  LogDestinationProvider,
+  LogFormatterProvider,
+  MemoryDestinationProvider,
+  PrettyFormatterProvider,
+} from "../index.ts";
+
+describe("SimpleFormatterProvider", () => {
+  class App {
+    log = $logger();
+  }
+
+  it("should format log entries correctly without color", ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "trace",
+        NO_COLOR: "true", // Simulate no color output
+      },
+    })
+      .with({
+        provide: LogFormatterProvider,
+        use: PrettyFormatterProvider,
+      })
+      .with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      });
+
+    const app = alepha.inject(App);
+
+    app.log.info("Test log message");
+
+    const output = alepha.inject(MemoryDestinationProvider);
+    const fmt = alepha.inject(PrettyFormatterProvider);
+
+    expect(output.logs[0].formatted).toMatch(
+      `[${fmt.formatTimestamp(output.logs[0].timestamp)}] INFO <app.App>: Test log message`,
+    );
+  });
+
+  it("should format error", ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "trace",
+        NO_COLOR: "true", // Simulate no color output
+      },
+    })
+      .with({
+        provide: LogFormatterProvider,
+        use: PrettyFormatterProvider,
+      })
+      .with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      });
+
+    const app = alepha.inject(App);
+
+    const error = new AlephaError("Test error message");
+    const anotherError = new Error("Another error message", { cause: error });
+
+    app.log.error("Test log message", anotherError);
+
+    const output = alepha.inject(MemoryDestinationProvider);
+    const fmt = alepha.inject(PrettyFormatterProvider);
+
+    expect(output.logs[0].formatted).toContain(
+      `[${fmt.formatTimestamp(output.logs[0].timestamp)}] ERROR <app.App>: Test log message`,
+    );
+    expect(output.logs[0].formatted).toContain("Error: Another error message");
+    expect(output.logs[0].formatted).toContain(
+      "Caused by: AlephaError: Test error message",
+    );
+  });
+
+  it("should format log json", ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "trace",
+        NO_COLOR: "true", // Simulate no color output
+      },
+    })
+      .with({
+        provide: LogFormatterProvider,
+        use: PrettyFormatterProvider,
+      })
+      .with({
+        provide: LogDestinationProvider,
+        use: MemoryDestinationProvider,
+      });
+
+    const app = alepha.inject(App);
+
+    app.log.info("Test log message", {
+      json: { key: "value" },
+      anotherKey: 123,
+    });
+
+    const output = alepha.inject(MemoryDestinationProvider);
+    const fmt = alepha.inject(PrettyFormatterProvider);
+
+    expect(output.logs[0].formatted).toEqual(
+      `[${fmt.formatTimestamp(output.logs[0].timestamp)}] INFO <app.App>: Test log message {"json":{"key":"value"},"anotherKey":123}`,
+    );
+  });
+});

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

@@ -0,0 +1,108 @@
+import { Alepha } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { describe, it } from "vitest";
+import {
+  $logger,
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "../index.ts";
+
+describe("$logger", () => {
+  class App {
+    log = $logger();
+  }
+
+  it("should log in-memory", ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "trace",
+      },
+    }).with({
+      provide: LogDestinationProvider,
+      use: MemoryDestinationProvider,
+    });
+    const output = alepha.inject(MemoryDestinationProvider);
+    const app = alepha.inject(App);
+
+    app.log.info("Test log message");
+
+    expect(output.logs[0].message).toBe("Test log message");
+    expect(output.logs[0].level).toBe("INFO");
+    expect(output.logs[0].service).toBe("App");
+    expect(output.logs[0].module).toBe("app");
+    expect(output.logs[0].app).toBeUndefined();
+    expect(output.logs[0].context).toBeUndefined();
+    expect(output.logs[0].timestamp).toBeDefined();
+
+    app.log.trace("Trace log message");
+    expect(output.logs[1].message).toBe("Trace log message");
+    app.log.warn("Warning log message");
+    expect(output.logs[2].message).toBe("Warning log message");
+    app.log.error("Error log message");
+    expect(output.logs[3].message).toBe("Error log message");
+    app.log.debug("Debug log message");
+    expect(output.logs[4].message).toBe("Debug log message");
+  });
+
+  it("should log with Alepha", async ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "info",
+      },
+    }).with({
+      provide: LogDestinationProvider,
+      use: MemoryDestinationProvider,
+    });
+    const output = alepha.inject(MemoryDestinationProvider);
+    const app = alepha.inject(App);
+    await alepha.start();
+    app.log.info("Test log message");
+    expect(output.logs.length).toBe(3);
+  });
+
+  it("should skip alepha logs", async ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "alepha.core:error,info",
+      },
+    }).with({
+      provide: LogDestinationProvider,
+      use: MemoryDestinationProvider,
+    });
+    const output = alepha.inject(MemoryDestinationProvider);
+    const app = alepha.inject(App);
+    await alepha.start();
+    app.log.info("Test log message");
+    expect(output.logs.length).toBe(1);
+  });
+
+  it("should emit log events for external listeners", async ({ expect }) => {
+    const alepha = Alepha.create({
+      env: {
+        LOG_LEVEL: "info",
+      },
+    }).with({
+      provide: LogDestinationProvider,
+      use: MemoryDestinationProvider,
+    });
+
+    const now = alepha.inject(DateTimeProvider).pause();
+    const app = alepha.inject(App);
+    const logEvents: any[] = [];
+
+    alepha.events.on("log", (event) => {
+      logEvents.push(event);
+    });
+
+    app.log.info("Test event emission", { testData: "value" });
+
+    expect(logEvents).toHaveLength(1);
+    expect(logEvents[0].message).toMatch(/Test event emission/);
+    expect(logEvents[0].entry.message).toBe("Test event emission");
+    expect(logEvents[0].entry.level).toBe("INFO");
+    expect(logEvents[0].entry.service).toBe("App");
+    expect(logEvents[0].entry.module).toBe("app");
+    expect(logEvents[0].entry.data).toEqual({ testData: "value" });
+    expect(logEvents[0].entry.timestamp).toBe(now.valueOf());
+  });
+});