alepha 0.14.2 → 0.14.3

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/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" }));
+  });
+});

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

@@ -0,0 +1,65 @@
+import { Alepha, t } from "alepha";
+import { describe, test } from "vitest";
+import { $route, ServerProvider } from "../index.ts";
+
+describe("$route", () => {
+  test("should return the correct route", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      $route = $route({
+        path: "/hello",
+        handler: () => "OK",
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const resp = await fetch(`${alepha.inject(ServerProvider).hostname}/hello`);
+    expect(await resp.text()).toBe("OK");
+  });
+
+  test("should return the correct route with queryParams", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      $route = $route({
+        path: "/hello",
+        schema: {
+          query: t.object({
+            a: t.optional(t.text()),
+            b: t.optional(t.array(t.text())),
+            c: t.optional(
+              t.object({
+                d: t.text(),
+              }),
+            ),
+          }),
+        },
+        handler: ({ query }) => JSON.stringify({ query }),
+      });
+    }
+
+    await alepha.with(TestApp).start();
+
+    const resp = await fetch(
+      `${alepha.inject(ServerProvider).hostname}/hello?a=1&b=["HELLO","WORLD"]&c=${encodeURIComponent(
+        JSON.stringify({
+          d: "e",
+        }),
+      )}`,
+    );
+
+    expect(await resp.json()).toEqual({
+      query: {
+        a: "1",
+        b: ["HELLO", "WORLD"],
+        c: {
+          d: "e",
+        },
+      },
+    });
+  });
+});

package/src/server/core/providers/ServerBodyParserProvider.spec.ts

@@ -0,0 +1,93 @@
+import { Alepha, t } from "alepha";
+import { describe, it } from "vitest";
+import { $action, HttpError } from "../index.ts";
+
+describe("ServerBodyParserProvider", () => {
+  it("should handle simple body", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      json = $action({
+        schema: {
+          body: t.object({
+            message: t.text(),
+          }),
+          response: t.object({
+            received: t.text(),
+          }),
+        },
+        handler: ({ body }) => ({ received: body.message }),
+      });
+      string = $action({
+        schema: {
+          body: t.text(),
+          response: t.object({
+            received: t.text(),
+          }),
+        },
+        handler: ({ body }) => ({ received: body }),
+      });
+    }
+
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(
+      await app.json.run({
+        body: { message: "Hello, World!" },
+      }),
+    ).toEqual({
+      received: "Hello, World!",
+    });
+
+    expect(app.json.getBodyContentType()).toBe("application/json");
+
+    expect(
+      await app.string.run({
+        body: "Hello, World!",
+      }),
+    ).toEqual({
+      received: "Hello, World!",
+    });
+
+    expect(app.string.getBodyContentType()).toBe("text/plain");
+  });
+
+  it("should reject big payload", async ({ expect }) => {
+    const alepha = Alepha.create();
+
+    class TestApp {
+      test = $action({
+        schema: {
+          body: t.object({
+            message: t.text({
+              maxLength: 1000000, // allow up to 1 million characters (for http client validation)
+            }),
+          }),
+          response: t.object({
+            received: t.text(),
+          }),
+        },
+        handler: ({ body }) => {
+          return { received: body.message };
+        },
+      });
+    }
+
+    const app = alepha.inject(TestApp);
+    await alepha.start();
+
+    expect(
+      await app.test
+        .fetch({
+          body: { message: "A".repeat(1000000) },
+        })
+        .catch((e) => HttpError.toJSON(e)),
+    ).toEqual({
+      error: "PayloadTooLargeError",
+      status: 413,
+      message: "Request body size limit exceeded",
+      requestId: expect.any(String),
+    });
+  });
+});

package/src/server/core/providers/ServerLoggerProvider.spec.ts

@@ -0,0 +1,100 @@
+import { Alepha } from "alepha";
+import {
+  $logger,
+  LogDestinationProvider,
+  MemoryDestinationProvider,
+} from "alepha/logger";
+import { beforeEach, describe, it } from "vitest";
+import {
+  $action,
+  AlephaServer,
+  HttpError,
+  ServerLoggerProvider,
+} from "../index.ts";
+
+class App {
+  log = $logger();
+  ping = $action({
+    handler: () => {
+      this.log.info("!!");
+      return "pong";
+    },
+  });
+  silent = $action({
+    silent: true,
+    handler: () => {
+      this.log.info("this message should be logged");
+      return "silent";
+    },
+  });
+  error = $action({
+    handler: () => {
+      throw new HttpError({
+        message: "Sorry",
+        status: 400,
+      });
+    },
+  });
+}
+
+const alepha = Alepha.create({
+  env: {
+    LOG_LEVEL: "info",
+  },
+})
+  .with({
+    provide: LogDestinationProvider,
+    use: MemoryDestinationProvider,
+  })
+  .with(AlephaServer)
+  .with(ServerLoggerProvider);
+
+const app = alepha.inject(App);
+const log = alepha.inject(MemoryDestinationProvider);
+
+describe("ServerLoggerProvider", () => {
+  beforeEach(() => {
+    log.clear();
+  });
+
+  it("should log incoming request, custom logs, and request completed for ok response", async ({
+    expect,
+  }) => {
+    expect(log.logs.length).toBe(0);
+    const response = await app.ping.fetch();
+    expect(response.data).toBe("pong");
+    expect(log.logs[0].message).toBe("Incoming request");
+    expect(log.logs[1].message).toBe("!!");
+    expect(log.logs[2].message).toBe("Request completed");
+  });
+
+  it("should log incoming request, failure, and completion for error response", async ({
+    expect,
+  }) => {
+    expect(log.logs.length).toBe(0);
+    const response = await app.error
+      .fetch()
+      .then((it) => it.data)
+      .catch((e) => HttpError.toJSON(e));
+
+    expect(response).toEqual({
+      message: "Sorry",
+      status: 400,
+      error: "BadRequestError",
+      requestId: expect.any(String),
+    });
+    expect(log.logs[0].message).toBe("Incoming request");
+    expect(log.logs[1].message).toBe("Request has failed");
+    expect(log.logs[2].message).toBe("Request completed");
+  });
+
+  it("should not log request lifecycle for silent actions but still log custom messages", async ({
+    expect,
+  }) => {
+    expect(log.logs.length).toBe(0);
+    const response = await app.silent.fetch();
+    expect(response.data).toBe("silent");
+    expect(log.logs[0].message).toBe("this message should be logged");
+    expect(log.logs.length).toBe(1);
+  });
+});

package/src/server/core/providers/ServerProvider.ts

@@ -203,7 +203,9 @@ export class ServerProvider {
     }
 
     if (Buffer.isBuffer(response.body)) {
-      ev.res = new Response(response.body.buffer as ArrayBuffer, {
+      // Use Uint8Array to avoid Buffer pooling issues where .buffer returns
+      // the entire underlying ArrayBuffer which may be larger than the actual data
+      ev.res = new Response(new Uint8Array(response.body), {
         status: response.status,
         headers: response.headers,
       });

package/src/server/core/services/HttpClient.spec.ts

@@ -0,0 +1,123 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import {
+  $route,
+  BadRequestError,
+  HttpClient,
+  HttpError,
+  ServerProvider,
+} from "../index.ts";
+
+describe("HttpClient", () => {
+  test("should fetch a URL", async ({ expect }) => {
+    const alepha = Alepha.create();
+    class TestApp {
+      root = $route({
+        path: "/",
+        handler: () => "Hello, World!",
+      });
+    }
+    const client = alepha.with(TestApp).inject(HttpClient);
+    await alepha.start();
+
+    const resp = await client.fetch<string>(
+      `${alepha.inject(ServerProvider).hostname}`,
+    );
+
+    // response looks like Axios response
+    expect(resp.data).toBe("Hello, World!");
+  });
+
+  test("should throw on Error", async ({ expect }) => {
+    const alepha = Alepha.create();
+    class TestApp {
+      root = $route({
+        path: "/",
+        handler: () => {
+          throw new BadRequestError();
+        },
+      });
+    }
+    const client = alepha.with(TestApp).inject(HttpClient);
+    await alepha.start();
+
+    const resp = await client
+      .fetch<string>(`${alepha.inject(ServerProvider).hostname}`)
+      .catch((e) => e);
+
+    expect(resp).toBeInstanceOf(HttpError);
+    expect(HttpError.toJSON(resp)).toEqual({
+      error: "BadRequestError",
+      message: "Invalid request body",
+      status: 400,
+      requestId: expect.any(String),
+    });
+  });
+
+  test("should handle empty query params", async ({ expect }) => {
+    const alepha = Alepha.create();
+    const client = alepha.inject(HttpClient);
+    await alepha.start();
+
+    expect(client.queryParams("", {}, {})).toEqual("");
+  });
+
+  test("should handle simple query params", async ({ expect }) => {
+    const alepha = Alepha.create();
+    const client = alepha.inject(HttpClient);
+    await alepha.start();
+
+    expect(
+      client.queryParams(
+        "",
+        {},
+        {
+          query: {
+            hello: "world",
+            a: "b",
+          },
+        },
+      ),
+    ).toEqual("?hello=world&a=b");
+  });
+
+  test("should handle undefined query params", async ({ expect }) => {
+    const alepha = Alepha.create();
+    const client = alepha.inject(HttpClient);
+    await alepha.start();
+
+    expect(
+      client.queryParams(
+        "",
+        {},
+        {
+          query: {
+            hello: undefined as any,
+            a: "b",
+          },
+        },
+      ),
+    ).toEqual("?a=b");
+  });
+
+  test("should handle json", async ({ expect }) => {
+    const alepha = Alepha.create();
+    const client = alepha.inject(HttpClient);
+    await alepha.start();
+
+    expect(
+      client.queryParams(
+        "",
+        {},
+        {
+          query: {
+            tags: ["a", "b"],
+            user: { name: "john" },
+          },
+        },
+      ),
+    ).toEqual(
+      `?tags=${encodeURIComponent(JSON.stringify(["a", "b"]))}&user=${encodeURIComponent(JSON.stringify({ name: "john" }))}`,
+    );
+  });
+});