alepha 0.14.2 → 0.14.4

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

@@ -27,6 +27,9 @@ export class ServerProvider {
   protected readonly internalServerErrorMessage = "Internal Server Error";
 
   public get hostname(): string {
+    if (this.alepha.isViteDev()) {
+      return `http://localhost:${this.alepha.env.SERVER_PORT}`;
+    }
     return ""; // no hostname in serverless mode
   }
 
@@ -116,9 +119,16 @@ export class ServerProvider {
     // if response.body is web stream
     if (response.body instanceof ReadableStream) {
       res.writeHead(response.status, response.headers);
+      // Flush headers immediately and disable Nagle's algorithm for streaming
+      res.flushHeaders();
+      res.socket?.setNoDelay(true);
       try {
         for await (const chunk of response.body) {
-          res.write(chunk);
+          const canContinue = res.write(chunk);
+          // If the internal buffer is full, wait for it to drain
+          if (!canContinue) {
+            await new Promise<void>((resolve) => res.once("drain", resolve));
+          }
         }
       } catch (error) {
         this.log.error("Error piping proxy response stream", error);
@@ -203,7 +213,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" }))}`,
+    );
+  });
+});

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

@@ -0,0 +1,111 @@
+import { Alepha } from "alepha";
+import { describe, it } from "vitest";
+import { UserAgentParser } from "../index.ts";
+
+describe("UserAgentParser", () => {
+  const alepha = Alepha.create();
+  const parser = alepha.inject(UserAgentParser);
+
+  it("should parse Windows user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("Windows");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("DESKTOP");
+
+    const ua2 =
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 Safari/537.36";
+    const result2 = parser.parse(ua2);
+    expect(result2.os).toBe("Windows");
+    expect(result2.browser).toBe("Chrome");
+    expect(result2.device).toBe("DESKTOP");
+
+    const firefoxUa =
+      "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0";
+    const firefoxResult = parser.parse(firefoxUa);
+    expect(firefoxResult.os).toBe("Windows");
+    expect(firefoxResult.browser).toBe("Firefox");
+    expect(firefoxResult.device).toBe("DESKTOP");
+  });
+
+  it("should parse Android user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (Linux; Android 10; Pixel 3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.149 MOBILE Safari/537.36";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("Android");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("MOBILE");
+  });
+
+  it("should parse iOS user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 MOBILE/15E148 Safari/604.1";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("iOS");
+    expect(result.browser).toBe("Safari");
+    expect(result.device).toBe("MOBILE");
+  });
+
+  it("should parse MacOS user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0 Safari/605.1.15";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("MacOS");
+    expect(result.browser).toBe("Safari");
+    expect(result.device).toBe("DESKTOP");
+  });
+
+  it("should parse Linux user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("Linux");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("DESKTOP");
+  });
+
+  it("should parse FreeBSD user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (X11; FreeBSD amd64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("FreeBSD");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("DESKTOP");
+  });
+
+  it("should parse OpenBSD user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (X11; OpenBSD amd64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("OpenBSD");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("DESKTOP");
+  });
+
+  it("should parse ChromeOS user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (X11; CrOS x86_64 12345.67.89) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("ChromeOS");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("DESKTOP");
+  });
+
+  it("should parse BlackBerry user agent", ({ expect }) => {
+    const ua =
+      "Mozilla/5.0 (BB10; Touch) AppleWebKit/537.36 (KHTML, like Gecko) Version/10.3.2.2876 MOBILE Safari/537.36";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("BlackBerry");
+    expect(result.browser).toBe("Safari");
+    expect(result.device).toBe("MOBILE");
+  });
+
+  it("should parse empty string", ({ expect }) => {
+    const ua = "";
+    const result = parser.parse(ua);
+    expect(result.os).toBe("Windows");
+    expect(result.browser).toBe("Chrome");
+    expect(result.device).toBe("DESKTOP");
+  });
+});