alepha 0.14.2 → 0.14.3

package/src/router/__tests__/match.spec.ts

@@ -0,0 +1,252 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { RouterProvider } from "../providers/RouterProvider.ts";
+
+interface TestRoute {
+  path: string;
+  name: string;
+  mapping?: Record<string, string>;
+}
+
+class TestRouterProvider extends RouterProvider<TestRoute> {
+  public push(route: TestRoute) {
+    super.push(route);
+  }
+}
+
+// A type-safe helper to create the router instance for tests
+const setupRouter = () => {
+  const router = new TestRouterProvider();
+
+  const add = (path: string, name: string) => {
+    router.push({ path, name });
+  };
+
+  const match = (path: string) => {
+    const { route, params } = router.match(path);
+    return {
+      name: route?.name ?? null, // Use null for clarity on no-match
+      params: params ?? {},
+    };
+  };
+
+  return { router, add, match };
+};
+
+describe("match", () => {
+  let router: RouterProvider<{ name: string; path: string }>;
+  let add: (path: string, name: string) => void;
+  let match: (path: string) => {
+    name: string | null;
+    params: Record<string, string>;
+  };
+
+  beforeEach(() => {
+    const setup = setupRouter();
+    router = setup.router;
+    add = setup.add;
+    match = setup.match;
+  });
+
+  describe("Static Routing", () => {
+    test("should match basic static routes", () => {
+      add("/", "home");
+      add("/about", "about");
+      add("/contact-us", "contact");
+
+      expect(match("/")).toEqual({ name: "home", params: {} });
+      expect(match("/about")).toEqual({ name: "about", params: {} });
+      expect(match("/contact-us")).toEqual({ name: "contact", params: {} });
+    });
+
+    test("should handle nested static routes", () => {
+      add("/dashboard/settings/profile", "profile_settings");
+      expect(match("/dashboard/settings/profile")).toEqual({
+        name: "profile_settings",
+        params: {},
+      });
+    });
+
+    test("should be case-insensitive for static parts", () => {
+      add("/Case/Sensitive/Path", "case_path");
+      expect(match("/case/sensitive/path")).toEqual({
+        name: "case_path",
+        params: {},
+      });
+      expect(match("/CASE/SENSITIVE/PATH")).toEqual({
+        name: "case_path",
+        params: {},
+      });
+    });
+
+    test("should handle trailing slashes", () => {
+      add("/about/", "about_with_slash");
+      add("/contact", "contact_no_slash");
+
+      expect(match("/about")).toEqual({ name: "about_with_slash", params: {} });
+      expect(match("/contact/")).toEqual({
+        name: "contact_no_slash",
+        params: {},
+      });
+    });
+
+    test("should ignore query parameters when matching", () => {
+      add("/search", "search_page");
+      expect(match("/search?q=alepha&page=1")).toEqual({
+        name: "search_page",
+        params: {},
+      });
+    });
+  });
+
+  describe("Parameter Routing", () => {
+    test("should match a single parameter", () => {
+      add("/posts/:slug", "post_by_slug");
+      expect(match("/posts/hello-world")).toEqual({
+        name: "post_by_slug",
+        params: { slug: "hello-world" },
+      });
+    });
+
+    test("should match multiple parameters in a route", () => {
+      add("/products/:category/:productId", "product_details");
+      expect(match("/products/electronics/12345")).toEqual({
+        name: "product_details",
+        params: { category: "electronics", productId: "12345" },
+      });
+    });
+
+    test("should maintain case for parameter values", () => {
+      add("/users/:username", "user_profile");
+      expect(match("/users/JohnDoe")).toEqual({
+        name: "user_profile",
+        params: { username: "JohnDoe" },
+      });
+    });
+
+    test("should prefer a static route over a parameterized one at the same level", () => {
+      add("/team/:member", "team_member");
+      add("/team/new", "team_new");
+
+      expect(match("/team/new")).toEqual({ name: "team_new", params: {} });
+      expect(match("/team/jane")).toEqual({
+        name: "team_member",
+        params: { member: "jane" },
+      });
+    });
+  });
+
+  describe("Double Parameter Mapping (The Fix)", () => {
+    test("should correctly map different parameter names at the same level", () => {
+      add("/users/:id", "user_by_id");
+      add("/users/:userId/posts", "posts_by_userId");
+      add("/users/:user_id/posts/:postId", "post_by_user_id_and_post_id");
+
+      // Test first route
+      const match1 = match("/users/123");
+      expect(match1).toEqual({ name: "user_by_id", params: { id: "123" } });
+
+      // Test second route, ensuring `userId` is mapped correctly from `id`
+      const match2 = match("/users/abc/posts");
+      expect(match2).toEqual({
+        name: "posts_by_userId",
+        params: { userId: "abc" },
+      });
+
+      // Test third route with two mappings
+      const match3 = match("/users/abc/posts/xyz");
+      expect(match3).toEqual({
+        name: "post_by_user_id_and_post_id",
+        params: { user_id: "abc", postId: "xyz" },
+      });
+    });
+
+    test("should handle a mix of static and mapped params", () => {
+      add("/api/v1/items/:id", "get_item");
+      add("/api/v1/items/:itemId/details", "get_item_details");
+
+      expect(match("/api/v1/items/42")).toEqual({
+        name: "get_item",
+        params: { id: "42" },
+      });
+      expect(match("/api/v1/items/42/details")).toEqual({
+        name: "get_item_details",
+        params: { itemId: "42" },
+      });
+    });
+  });
+
+  describe("Wildcard Routing", () => {
+    test("should match a final wildcard", () => {
+      add("/files/*", "file_path");
+      expect(match("/files/documents/report.pdf")).toEqual({
+        name: "file_path",
+        params: { "*": "documents/report.pdf" },
+      });
+    });
+
+    test("should match a root-level wildcard", () => {
+      add("/*", "catch_all");
+      expect(match("/anything/goes/here")).toEqual({
+        name: "catch_all",
+        params: { "*": "anything/goes/here" },
+      });
+      // An empty path for the wildcard
+      expect(match("/")).toEqual({ name: "catch_all", params: { "*": "" } });
+    });
+
+    test("should prefer a more specific route over a wildcard", () => {
+      add("/*", "catch_all");
+      add("/about", "about_page");
+      add("/users/:id", "user_page");
+
+      expect(match("/about")).toEqual({ name: "about_page", params: {} });
+      expect(match("/users/1")).toEqual({
+        name: "user_page",
+        params: { id: "1" },
+      });
+      expect(match("/something-else")).toEqual({
+        name: "catch_all",
+        params: { "*": "something-else" },
+      });
+    });
+
+    test("should handle wildcards after a parameter", () => {
+      add("/proxy/:service/*", "service_proxy");
+      expect(match("/proxy/auth-service/api/v2/login")).toEqual({
+        name: "service_proxy",
+        params: { service: "auth-service", "*": "api/v2/login" },
+      });
+    });
+  });
+
+  describe("Error Handling and Edge Cases", () => {
+    test("should return null if no route matches", () => {
+      add("/home", "home");
+      expect(match("/nonexistent")).toEqual({ name: null, params: {} });
+    });
+
+    test("should throw an error for invalid route paths during push", () => {
+      // Does not start with '/'
+      expect(() => add("no-slash", "invalid")).toThrow();
+      // Invalid character '*'
+      expect(() => add("/invalid*path", "invalid")).toThrow();
+      // Parameter without a name
+      expect(() => add("/users/:/details", "invalid")).toThrow();
+      // Wildcard not at the end
+      expect(() => add("/files/*/more", "invalid")).toThrow();
+      // Double wildcard
+      expect(() => add("/files/**", "invalid")).toThrow();
+      // Empty parameter name
+      expect(() => add("/items/{}/info", "invalid")).toThrow();
+    });
+
+    test("should throw an error for invalid paths during match", () => {
+      expect(() => match("not-a-valid-path")).toThrow();
+    });
+
+    test("should handle empty path parts correctly", () => {
+      add("/a//b", "double_slash"); // Should be treated as /a/b
+      expect(match("/a/b")).toEqual({ name: "double_slash", params: {} });
+    });
+  });
+});

package/src/router/providers/RouterProvider.spec.ts

@@ -0,0 +1,197 @@
+import { describe, it } from "vitest";
+import { RouterProvider } from "../providers/RouterProvider.ts";
+
+interface TestRoute {
+  name: string;
+  path: string;
+}
+
+class TestRouterProvider extends RouterProvider<TestRoute> {
+  public push(route: TestRoute) {
+    super.push(route);
+  }
+}
+
+const playground = () => {
+  const router = new TestRouterProvider();
+  const add = (path: string, name: string) => {
+    router.push({
+      path,
+      name,
+    });
+  };
+
+  const match = (path: string) => {
+    const { route, params } = router.match(`${path}?a=b`);
+    return {
+      name: route?.name ?? "null",
+      params: params,
+    };
+  };
+
+  return {
+    add,
+    match,
+    router,
+  };
+};
+
+describe("RouterProvider", () => {
+  it("should match routes with static paths, params, and wildcards", ({
+    expect,
+  }) => {
+    const { add, match } = playground();
+
+    add("/", "home");
+    add("/about", "about");
+    add("/dist/", "dist");
+    add("/users", "users");
+    add("/users/:name", "users-by-name");
+    add("/users/:name/INFO", "users-by-name-info");
+    add("/users/:name/x/y/z", "users-by-name-x-y-z");
+    add("/useRs/:name/x/*", "users-by-name-x-not-found");
+    add("/*", "not-found");
+
+    expect(match("/")).toEqual({
+      name: "home",
+      params: {},
+    });
+
+    expect(match("/about")).toEqual({
+      name: "about",
+      params: {},
+    });
+
+    expect(match("/dist")).toEqual({
+      name: "dist",
+      params: {},
+    });
+
+    expect(match("/dist/")).toEqual({
+      name: "dist",
+      params: {},
+    });
+
+    expect(match("/users/jack")).toEqual({
+      name: "users-by-name",
+      params: {
+        name: "jack",
+      },
+    });
+
+    expect(match("/users/jack/info")).toEqual({
+      name: "users-by-name-info",
+      params: {
+        name: "jack",
+      },
+    });
+
+    expect(match("/users/jack/info/other")).toEqual({
+      name: "not-found",
+      params: {
+        name: "jack",
+      },
+    });
+
+    expect(match("/users/JACK/x")).toEqual({
+      name: "users-by-name-x-not-found",
+      params: {
+        name: "JACK",
+      },
+    });
+
+    expect(match("/users/jack/x/y")).toEqual({
+      name: "users-by-name-x-not-found",
+      params: {
+        name: "jack",
+      },
+    });
+
+    expect(match("/users/jack/x/y/z")).toEqual({
+      name: "users-by-name-x-y-z",
+      params: {
+        name: "jack",
+      },
+    });
+
+    expect(match("/users/jack/x/abc/def")).toEqual({
+      name: "users-by-name-x-not-found",
+      params: {
+        "*": "abc/def",
+        name: "jack",
+      },
+    });
+
+    expect(match("/weird")).toEqual({
+      name: "not-found",
+      params: {
+        "*": "weird",
+      },
+    });
+  });
+
+  it("should return null for paths with no matching routes", ({ expect }) => {
+    const { match } = playground();
+    expect(match("/")).toEqual({
+      name: "null",
+      params: {},
+    });
+    expect(match("/abc/def")).toEqual({
+      name: "null",
+      params: {},
+    });
+  });
+
+  it("should throw error for invalid path formats", ({ expect }) => {
+    const { match } = playground();
+    expect(() => match("x")).toThrowError();
+    expect(() => match("(*__*)")).toThrowError();
+  });
+
+  it("should match only wildcard route", ({ expect }) => {
+    const { add, match } = playground();
+    add("/*", "wildcard");
+    expect(match("/")).toEqual({
+      name: "wildcard",
+      params: {
+        "*": "",
+      },
+    });
+  });
+
+  it("should throw error when adding invalid path", ({ expect }) => {
+    const { add } = playground();
+    expect(() => add("*", "wildcard")).toThrowError();
+  });
+
+  it("should handle routes with params and wildcard", ({ expect }) => {
+    const { add, match } = playground();
+    add("/users/*", "users-not-found");
+    add("/users/:name/x/*", "users-by-name-x-not-found");
+    expect(match("/users/jack/x/y/z")).toEqual({
+      name: "users-by-name-x-not-found",
+      params: {
+        name: "jack",
+        "*": "y/z",
+      },
+    });
+  });
+
+  it("should handle routes with different param names", ({ expect }) => {
+    const { add, match } = playground();
+    add("/users/:id", "home");
+    add("/users/:userId/hello", "hello");
+    expect(match("/users/jack")).toEqual({
+      name: "home",
+      params: {
+        id: "jack",
+      },
+    });
+    expect(match("/users/jack/hello")).toEqual({
+      name: "hello",
+      params: {
+        userId: "jack",
+      },
+    });
+  });
+});

package/src/scheduler/__tests__/$scheduler-cron.spec.ts

@@ -0,0 +1,25 @@
+import { RedisLockProvider } from "alepha/lock/redis";
+import { describe, test } from "vitest";
+import { SharedLockProvider, testSchedulerBasic } from "./shared.ts";
+
+describe("$scheduler - cron", () => {
+  const scheduler = { cron: "0 * * * *" };
+
+  test("should trigger all apps", async () => {
+    await testSchedulerBasic({
+      scheduler,
+    });
+  });
+  test("should trigger one app (memory)", async () => {
+    await testSchedulerBasic({
+      lock: SharedLockProvider,
+      scheduler,
+    });
+  });
+  test("should trigger one app (redis)", { retry: 3 }, async () => {
+    await testSchedulerBasic({
+      lock: RedisLockProvider,
+      scheduler,
+    });
+  });
+});

package/src/scheduler/__tests__/$scheduler-interval.spec.ts

@@ -0,0 +1,25 @@
+import { RedisLockProvider } from "alepha/lock/redis";
+import { describe, test } from "vitest";
+import { SharedLockProvider, testSchedulerBasic } from "./shared.ts";
+
+describe("$scheduler - interval", () => {
+  const scheduler = { interval: [1, "minute"] } as any;
+
+  test("should trigger all apps", async () => {
+    await testSchedulerBasic({
+      scheduler,
+    });
+  });
+  test("should trigger one app (memory)", async () => {
+    await testSchedulerBasic({
+      lock: SharedLockProvider,
+      scheduler,
+    });
+  });
+  test("should trigger one app (redis)", { retry: 3 }, async () => {
+    await testSchedulerBasic({
+      lock: RedisLockProvider,
+      scheduler,
+    });
+  });
+});

package/src/scheduler/__tests__/shared.ts

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { Alepha, type Service } from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { LockProvider, MemoryLockProvider } from "alepha/lock";
+import { expect } from "vitest";
+import { $scheduler, type SchedulerPrimitiveOptions } from "../index.ts";
+
+const store: Record<string, string> = {};
+
+export class SharedLockProvider extends MemoryLockProvider {
+  store = store;
+}
+
+export const testSchedulerBasic = async (options: {
+  scheduler: Partial<SchedulerPrimitiveOptions>;
+  lock?: Service<LockProvider>;
+}) => {
+  let count = 0;
+
+  class TestApp {
+    t = $scheduler({
+      ...options.scheduler,
+      lock: !!options.lock,
+      handler: async () => {
+        count += 1;
+      },
+    });
+  }
+
+  const prefix = randomUUID();
+
+  const createApp = () => {
+    const alepha = Alepha.create({ env: { LOCK_PREFIX_KEY: prefix } });
+
+    if (options.lock) {
+      alepha.with({
+        provide: LockProvider,
+        use: options.lock,
+      });
+    }
+
+    alepha.with(DateTimeProvider);
+    alepha.with(TestApp);
+
+    return alepha;
+  };
+
+  const apps = [createApp(), createApp(), createApp(), createApp()];
+
+  expect(count).toEqual(0);
+
+  await Promise.all(apps.map((app) => app.start()));
+
+  expect(count).toEqual(0);
+
+  if (options.scheduler.interval) {
+    await Promise.all(
+      apps.map((app) => app.inject(DateTimeProvider).travel([64, "seconds"])),
+    );
+  } else {
+    await Promise.all(
+      apps.map((app) => app.inject(DateTimeProvider).travel([1, "hour"])),
+    );
+  }
+
+  await new Promise((r) => setTimeout(r, 100));
+
+  if (options.lock) {
+    await expect.poll(() => expect(count).toEqual(1)).toBeTruthy();
+  } else {
+    await expect
+      .poll(() => expect(count).toEqual(1 * apps.length))
+      .toBeTruthy();
+  }
+
+  await Promise.all(apps.map((app) => app.stop()));
+};