alepha 0.14.2 → 0.14.4

package/src/server/core/__tests__/ServerRouterProvider-getRoutes.spec.ts

@@ -0,0 +1,334 @@
+import { Alepha, t } from "alepha";
+import { describe, it } from "vitest";
+import { $action, $route, ServerRouterProvider } from "../index.ts";
+
+describe("ServerRouterProvider - getRoutes", () => {
+  it("should return all routes when no pattern is provided", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      action1 = $action({
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      action2 = $action({
+        path: "/posts",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      route1 = $route({
+        path: "/health",
+        handler: () => "OK",
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes();
+
+    expect(routes.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("should return routes matching wildcard pattern", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      users = $action({
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      userDetail = $action({
+        path: "/users/:id",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      posts = $action({
+        path: "/posts",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      health = $route({
+        path: "/health",
+        handler: () => "OK",
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes("/api/*");
+
+    // Should include the actions under /api/*
+    const paths = routes.map((r) => r.path);
+    expect(paths.length).toBeGreaterThanOrEqual(3);
+    expect(paths.some((p) => p.includes("/users"))).toBe(true);
+    expect(paths.some((p) => p.includes("/posts"))).toBe(true);
+    // health route should not match /api/*
+    expect(paths.some((p) => p === "/GET/health")).toBe(false);
+  });
+
+  it("should return empty array when pattern doesn't match any routes", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      users = $action({
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      posts = $action({
+        path: "/posts",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes("/v2/*");
+
+    expect(routes).toHaveLength(0);
+  });
+
+  it("should return empty array when exact pattern doesn't match", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      users = $action({
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes("/admin");
+
+    expect(routes).toHaveLength(0);
+  });
+
+  it("should differentiate between exact match and wildcard match patterns", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      apiInfo = $action({
+        path: "/api-info",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      apiUsers = $action({
+        path: "/api-users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      settings = $route({
+        path: "/settings",
+        handler: () => "OK",
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+
+    // Wildcard pattern matches multiple routes
+    const wildcardRoutes = routerProvider.getRoutes("/api/*");
+    expect(wildcardRoutes.length).toBeGreaterThan(0);
+  });
+
+  it("should return multiple routes for deep nested paths", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      level1 = $action({
+        path: "/v1/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      level2 = $action({
+        path: "/v1/users/:id/posts",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      level3 = $action({
+        path: "/v1/users/:id/posts/:postId/comments",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      v2 = $action({
+        path: "/v2/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes("/api/*");
+
+    // Should find nested routes under /api/*
+    expect(routes.length).toBeGreaterThanOrEqual(2);
+    const paths = routes.map((r) => r.path);
+    expect(paths.some((p) => p.includes("v1"))).toBe(true);
+    expect(paths.some((p) => p.includes("v2"))).toBe(true);
+  });
+
+  it("should match all routes with root wildcard pattern", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      health = $route({
+        path: "/health",
+        schema: { response: t.object({ status: t.string() }) },
+        handler: () => ({ status: "ok" }),
+      });
+
+      about = $route({
+        path: "/about",
+        schema: { response: t.object({ name: t.string() }) },
+        handler: () => ({ name: "app" }),
+      });
+
+      users = $action({
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes("/*");
+
+    expect(routes.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("should correctly filter by path prefix", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      publicApi = $action({
+        path: "/public/info",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      adminApi = $action({
+        path: "/admin/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      privateRoute = $route({
+        path: "/private",
+        handler: () => "private",
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+
+    // Get routes matching /api/* pattern
+    const apiRoutes = routerProvider.getRoutes("/api/*");
+    expect(apiRoutes.length).toBeGreaterThan(0);
+
+    // Get routes matching a specific non-api pattern
+    const privateRoutes = routerProvider.getRoutes("/private");
+    expect(privateRoutes.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it("should handle routes with method-specific paths", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      getUsers = $action({
+        method: "GET",
+        path: "/users",
+        schema: { response: t.array(t.object({ id: t.integer() })) },
+        handler: () => [],
+      });
+
+      createUser = $action({
+        method: "POST",
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      updateUser = $action({
+        method: "PATCH",
+        path: "/users/:id",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const routes = routerProvider.getRoutes("/api/*");
+
+    // Should return routes with different HTTP methods for /users path
+    expect(routes.length).toBeGreaterThanOrEqual(2);
+    const paths = routes.map((r) => r.path);
+    expect(paths.some((p) => p.includes("/users"))).toBe(true);
+  });
+
+  it("should be case-sensitive for path matching", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      users = $action({
+        path: "/users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+
+      users2 = $action({
+        path: "/Users",
+        schema: { response: t.object({ id: t.integer() }) },
+        handler: () => ({ id: 1 }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const routerProvider = alepha.inject(ServerRouterProvider);
+    const allRoutes = routerProvider.getRoutes();
+
+    // Both routes should exist
+    expect(allRoutes.length).toBeGreaterThanOrEqual(2);
+  });
+});

package/src/server/core/__tests__/ServerRouterProvider-requestId.spec.ts

@@ -0,0 +1,129 @@
+import { Alepha } from "alepha";
+import { beforeEach, describe, it } from "vitest";
+import { $action, HttpClient, HttpError, ServerProvider } from "../index.ts";
+
+class TestApp {
+  // HttpError with custom message
+  httpError = $action({
+    handler: () => {
+      throw new HttpError({
+        message: "Custom error message",
+        status: 400,
+      });
+    },
+  });
+
+  // Generic Error without status (500)
+  genericError = $action({
+    handler: () => {
+      throw new Error("Something went wrong");
+    },
+  });
+}
+
+describe("ServerRouterProvider - requestId", () => {
+  let alepha: Alepha;
+  let client: HttpClient;
+  let hostname: string;
+
+  beforeEach(async () => {
+    alepha = Alepha.create().with(TestApp);
+    client = alepha.inject(HttpClient);
+    await alepha.start();
+    hostname = alepha.inject(ServerProvider).hostname;
+  });
+
+  it("should include requestId in raw HTTP error response for HttpError", async ({
+    expect,
+  }) => {
+    // Make raw HTTP request to see the actual JSON response
+    const response = await fetch(`${hostname}/api/httpError`, {
+      headers: {
+        "x-request-id": "test-request-123",
+      },
+    });
+
+    expect(response.status).toBe(400);
+
+    const responseText = await response.text();
+    const responseJson = JSON.parse(responseText);
+
+    // Check that the raw HTTP response includes requestId
+    expect(responseJson).toMatchObject({
+      message: "Custom error message",
+      status: 400,
+      error: "BadRequestError",
+      requestId: "test-request-123",
+    });
+  });
+
+  it("should include requestId in raw HTTP error response for generic error", async ({
+    expect,
+  }) => {
+    // Make raw HTTP request to see the actual JSON response
+    const response = await fetch(`${hostname}/api/genericError`, {
+      headers: {
+        "x-request-id": "test-request-789",
+      },
+    });
+
+    expect(response.status).toBe(500);
+
+    const responseText = await response.text();
+    const responseJson = JSON.parse(responseText);
+
+    // Check that the raw HTTP response includes requestId
+    expect(responseJson).toMatchObject({
+      status: 500,
+      error: "InternalServerError",
+      message: "Something went wrong",
+      requestId: "test-request-789",
+    });
+  });
+
+  it("should auto-generate requestId in raw response when not provided", async ({
+    expect,
+  }) => {
+    // Make raw HTTP request without providing requestId
+    const response = await fetch(`${hostname}/api/genericError`);
+
+    expect(response.status).toBe(500);
+
+    const responseText = await response.text();
+    const responseJson = JSON.parse(responseText);
+
+    // Check that the raw HTTP response includes an auto-generated requestId
+    expect(responseJson).toMatchObject({
+      status: 500,
+      error: "InternalServerError",
+      message: "Something went wrong",
+    });
+
+    // Should have a requestId even when not provided in headers
+    expect(responseJson.requestId).toBeDefined();
+    expect(typeof responseJson.requestId).toBe("string");
+    expect(responseJson.requestId.length).toBeGreaterThan(0);
+  });
+
+  it("should properly handle error with requestId through HttpClient", async ({
+    expect,
+  }) => {
+    try {
+      await client.fetch(`${hostname}/api/httpError`, {
+        headers: {
+          "x-request-id": "test-request-client",
+        },
+      });
+      // Should not reach here
+      expect(true).toBe(false);
+    } catch (error) {
+      if (error instanceof HttpError) {
+        const errorJson = HttpError.toJSON(error);
+        expect(errorJson.requestId).toBe("test-request-client");
+      } else {
+        // For now, let's see what we actually get
+        expect(error).toBeInstanceOf(Error);
+      }
+    }
+  });
+});

package/src/server/core/helpers/ServerReply.ts

@@ -12,9 +12,9 @@ export class ServerReply {
   public body?: any;
 
   /**
-   * Redirect to a given URL with optional status code (default 302).
+   * Redirect to a given URL with optional status code (default 301).
    */
-  public redirect(url: string, status: number = 302): void {
+  public redirect(url: string, status: number = 301): void {
     this.status = status;
     this.headers.location = url;
   }

package/src/server/core/primitives/$action.spec.ts

@@ -0,0 +1,191 @@
+import { Alepha, t } from "alepha";
+import { FileSystemProvider } from "alepha/file";
+import { describe, test } from "vitest";
+import { $action } from "../index.ts";
+
+describe("$action", () => {
+  test("should expose api", async ({ expect }) => {
+    class Api {
+      hello = $action({
+        schema: {
+          params: t.object({
+            name: t.text(),
+          }),
+          query: t.object({
+            transform: t.optional(t.enum(["uppercase"])),
+          }),
+          response: t.object({
+            message: t.text(),
+          }),
+        },
+        handler: ({ params, query }) => {
+          const message = `Hello ${params.name}`;
+          if (query.transform === "uppercase") {
+            return {
+              message: message.toUpperCase(),
+            };
+          }
+          return { message };
+        },
+      });
+    }
+
+    const alepha = Alepha.create();
+    const app = alepha.inject(Api);
+    await alepha.start();
+
+    expect(await app.hello.run({ params: { name: "John" } })).toStrictEqual({
+      message: "Hello John",
+    });
+
+    expect(
+      await app.hello.run({
+        params: { name: "John" },
+        query: { transform: "uppercase" },
+      }),
+    ).toStrictEqual({
+      message: "HELLO JOHN",
+    });
+
+    expect(
+      await app.hello.fetch({ params: { name: "John" } }).then((it) => it.data),
+    ).toStrictEqual({
+      message: "Hello John",
+    });
+
+    expect(
+      await app.hello
+        .fetch({
+          params: { name: "John" },
+          query: { transform: "uppercase" },
+        })
+        .then((it) => it.data),
+    ).toStrictEqual({
+      message: "HELLO JOHN",
+    });
+  });
+
+  test("should not be exposed when disabled", async ({ expect }) => {
+    const alepha = Alepha.create();
+    class TestApp {
+      a1 = $action({
+        handler: () => "ok:a1",
+      });
+      a2 = $action({
+        handler: () => "ok:a2",
+        disabled: true,
+      });
+    }
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(await app.a1.fetch({}).then((it) => it.data)).toBe("ok:a1");
+    expect(await app.a2.fetch({}).then((it) => it.data)).toBe("Not Found");
+    // note: $action disabled is callable locally
+    expect(await app.a2.run({})).toBe("ok:a2");
+  });
+
+  test("should return nothing", async ({ expect }) => {
+    const alepha = Alepha.create();
+    class TestApp {
+      test = $action({
+        schema: {
+          response: t.void(), // force no response
+        },
+        handler: () => {},
+      });
+    }
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(await app.test.run({})).toStrictEqual(undefined);
+    expect(await app.test.fetch({}).then((it) => it.data)).toStrictEqual(
+      undefined,
+    );
+
+    const response = await app.test.fetch({});
+    expect(response.status).toBe(204); // No Content
+  });
+
+  test("should return an object", async ({ expect }) => {
+    const alepha = Alepha.create();
+    class TestApp {
+      test = $action({
+        schema: {
+          response: t.json(),
+        },
+        handler: () => ({
+          ok: true,
+        }),
+      });
+    }
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(await app.test()).toStrictEqual({ ok: true });
+    expect(await app.test.run({})).toStrictEqual({ ok: true });
+    expect(await app.test.fetch({}).then((it) => it.data)).toStrictEqual({
+      ok: true,
+    });
+  });
+
+  test("should return a file", async ({ expect }) => {
+    const alepha = Alepha.create();
+    const fileSystem = alepha.inject(FileSystemProvider);
+    class TestApp {
+      test = $action({
+        schema: {
+          response: t.file(), // expect a file response
+        },
+        handler: () =>
+          fileSystem.createFile({
+            buffer: Buffer.from("hello"),
+            name: "hello.txt",
+            type: "text/plain",
+          }),
+      });
+    }
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(await app.test().then((it) => it.text())).toBe("hello");
+    expect(await app.test.run().then((it) => it.text())).toBe("hello");
+    expect(await app.test.fetch({}).then((it) => it.data.text())).toBe("hello");
+
+    const file = await app.test.run({});
+    expect(file.name).toBe("hello.txt");
+    expect(file.type).toBe("text/plain");
+  });
+
+  test("should filter fields", async ({ expect }) => {
+    const alepha = Alepha.create();
+    const fileSystem = alepha.inject(FileSystemProvider);
+    class TestApp {
+      test = $action({
+        schema: {
+          body: t.object({
+            extra: t.text(),
+          }),
+          response: t.string(),
+        },
+        handler: ({ body }) => JSON.stringify(body),
+      });
+    }
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(
+      await app.test.run({
+        body: { extra: "some extra", invalid: "nope" },
+      } as any),
+    ).toBe(JSON.stringify({ extra: "some extra" }));
+
+    expect(
+      await app.test
+        .fetch({
+          body: { extra: "some extra", invalid: "nope" },
+        } as any)
+        .then((it) => it.data),
+    ).toBe(JSON.stringify({ extra: "some extra" }));
+  });
+});