alepha 0.22.0 → 0.24.0

package/src/server/core/__tests__/$sse.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, AlephaError, t } from "alepha";
+import { Alepha, AlephaError, z } from "alepha";
 import { LinkProvider, ServerLinksProvider } from "alepha/server/links";
 import { describe, test } from "vitest";
 import { $sse } from "../index.ts";
@@ -8,9 +8,9 @@ describe("$sse", () => {
     class Api {
       events = $sse({
         schema: {
-          data: t.object({
-            type: t.text(),
-            message: t.text(),
+          data: z.object({
+            type: z.text(),
+            message: z.text(),
           }),
         },
         handler: async ({ emit, close }) => {
@@ -40,8 +40,8 @@ describe("$sse", () => {
     class Api {
       notifications = $sse({
         schema: {
-          data: t.object({
-            id: t.number(),
+          data: z.object({
+            id: z.number(),
           }),
         },
         handler: async ({ close }) => {
@@ -65,8 +65,8 @@ describe("$sse", () => {
       feed = $sse({
         path: "/custom/feed",
         schema: {
-          data: t.object({
-            value: t.text(),
+          data: z.object({
+            value: z.text(),
           }),
         },
         handler: async ({ close }) => {
@@ -86,11 +86,11 @@ describe("$sse", () => {
     class Api {
       stream = $sse({
         schema: {
-          params: t.object({
-            id: t.text(),
+          params: z.object({
+            id: z.text(),
           }),
-          data: t.object({
-            value: t.text(),
+          data: z.object({
+            value: z.text(),
           }),
         },
         handler: async ({ params, emit, close }) => {
@@ -118,8 +118,8 @@ describe("$sse", () => {
     class Api {
       events = $sse({
         schema: {
-          data: t.object({
-            seq: t.number(),
+          data: z.object({
+            seq: z.number(),
           }),
         },
         handler: async ({ emit, close }) => {
@@ -153,8 +153,8 @@ describe("$sse", () => {
     class Api {
       failing = $sse({
         schema: {
-          data: t.object({
-            value: t.text(),
+          data: z.object({
+            value: z.text(),
           }),
         },
         handler: async ({ emit }) => {
@@ -182,8 +182,8 @@ describe("$sse", () => {
     class Api {
       autoClose = $sse({
         schema: {
-          data: t.object({
-            n: t.number(),
+          data: z.object({
+            n: z.number(),
           }),
         },
         handler: async ({ emit }) => {
@@ -210,8 +210,8 @@ describe("$sse", () => {
     class Api {
       ticker = $sse({
         schema: {
-          data: t.object({
-            tick: t.number(),
+          data: z.object({
+            tick: z.number(),
           }),
         },
         handler: async ({ emit, close }) => {
@@ -238,8 +238,8 @@ describe("$sse", () => {
       disabled = $sse({
         disabled: true,
         schema: {
-          data: t.object({
-            value: t.text(),
+          data: z.object({
+            value: z.text(),
           }),
         },
         handler: async ({ close }) => {
@@ -261,8 +261,8 @@ describe("$sse", () => {
     class Api {
       chat = $sse({
         schema: {
-          body: t.object({ prompt: t.text() }),
-          data: t.object({ token: t.text() }),
+          body: z.object({ prompt: z.text() }),
+          data: z.object({ token: z.text() }),
         },
         handler: async ({ body, emit }) => {
           emit({ token: "Hello" });
@@ -291,8 +291,8 @@ describe("$sse", () => {
     class Api {
       chat = $sse({
         schema: {
-          body: t.object({ prompt: t.text() }),
-          data: t.object({ token: t.text() }),
+          body: z.object({ prompt: z.text() }),
+          data: z.object({ token: z.text() }),
         },
         handler: async ({ body, emit }) => {
           emit({ token: body.prompt });

package/src/server/core/__tests__/BunHttpServerProvider.bun.spec.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { $action, $route, AlephaServer, ServerProvider } from "../index.ts";
 
 // -------------------------------------------------------------------------------------------------------------------
@@ -46,7 +46,7 @@ describe("BunHttpServerProvider", () => {
         method: "GET",
         path: "/hello",
         schema: {
-          response: t.object({ message: t.text() }),
+          response: z.object({ message: z.text() }),
         },
         handler: async () => {
           return { message: "Hello from Bun!" };
@@ -83,8 +83,8 @@ describe("BunHttpServerProvider", () => {
         method: "POST",
         path: "/echo",
         schema: {
-          body: t.object({ input: t.text() }),
-          response: t.object({ output: t.text() }),
+          body: z.object({ input: z.text() }),
+          response: z.object({ output: z.text() }),
         },
         handler: async ({ body }) => {
           return { output: body.input };
@@ -125,8 +125,8 @@ describe("BunHttpServerProvider", () => {
         method: "GET",
         path: "/users/:id",
         schema: {
-          params: t.object({ id: t.text() }),
-          response: t.object({ id: t.text() }),
+          params: z.object({ id: z.text() }),
+          response: z.object({ id: z.text() }),
         },
         handler: async ({ params }) => {
           return { id: params.id };

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

@@ -21,7 +21,7 @@ describe("HttpClient", () => {
     const client = alepha.with(TestApp).inject(HttpClient);
     await alepha.start();
 
-    const resp = await client.fetch<string>(
+    const resp = await client.fetch(
       `${alepha.inject(ServerProvider).hostname}`,
     );
 
@@ -43,7 +43,7 @@ describe("HttpClient", () => {
     await alepha.start();
 
     const resp = await client
-      .fetch<string>(`${alepha.inject(ServerProvider).hostname}`)
+      .fetch(`${alepha.inject(ServerProvider).hostname}`)
       .catch((e) => e);
 
     expect(resp).toBeInstanceOf(HttpError);

package/src/server/core/__tests__/NodeHttpServerProvider.spec.ts

@@ -34,7 +34,11 @@ describe("NodeHttpServerProvider", () => {
 
     test("production mode: waits for connections then closes", async () => {
       alepha = Alepha.create({
-        env: { NODE_ENV: "production", SERVER_PORT: 0 },
+        env: {
+          NODE_ENV: "production",
+          SERVER_PORT: 0,
+          APP_SECRET: "test-secret",
+        },
       });
       alepha.with(NodeHttpServerProvider);
 
@@ -57,7 +61,11 @@ describe("NodeHttpServerProvider", () => {
 
     test("production mode: forces close after timeout", async () => {
       alepha = Alepha.create({
-        env: { NODE_ENV: "production", SERVER_PORT: 0 },
+        env: {
+          NODE_ENV: "production",
+          SERVER_PORT: 0,
+          APP_SECRET: "test-secret",
+        },
       });
       alepha.with(NodeHttpServerProvider);
 
@@ -98,7 +106,11 @@ describe("NodeHttpServerProvider", () => {
 
     test("rejects new requests during shutdown", async () => {
       alepha = Alepha.create({
-        env: { NODE_ENV: "production", SERVER_PORT: 0 },
+        env: {
+          NODE_ENV: "production",
+          SERVER_PORT: 0,
+          APP_SECRET: "test-secret",
+        },
       });
       alepha.with(NodeHttpServerProvider);
 

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

@@ -1,5 +1,5 @@
 import { brotliCompressSync, deflateSync, gzipSync } from "node:zlib";
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, it } from "vitest";
 import { $action, HttpError } from "../index.ts";
 import {
@@ -14,11 +14,11 @@ describe("ServerBodyParserProvider", () => {
     class TestApp {
       json = $action({
         schema: {
-          body: t.object({
-            message: t.text(),
+          body: z.object({
+            message: z.text(),
           }),
-          response: t.object({
-            received: t.text(),
+          response: z.object({
+            received: z.text(),
           }),
         },
         handler: ({ body }) => ({ received: body.message }),
@@ -45,9 +45,9 @@ describe("ServerBodyParserProvider", () => {
     class TestApp {
       text = $action({
         schema: {
-          body: t.text(),
-          response: t.object({
-            received: t.text(),
+          body: z.text(),
+          response: z.object({
+            received: z.text(),
           }),
         },
         handler: ({ body }) => ({ received: body }),
@@ -74,13 +74,13 @@ describe("ServerBodyParserProvider", () => {
     class TestApp {
       test = $action({
         schema: {
-          body: t.object({
-            message: t.text({
+          body: z.object({
+            message: z.text({
               maxLength: 1_000_000,
             }),
           }),
-          response: t.object({
-            received: t.text(),
+          response: z.object({
+            received: z.text(),
           }),
         },
         handler: ({ body }) => {
@@ -305,7 +305,7 @@ describe("ServerBodyParserProvider", () => {
       },
     });
 
-    const result = await parser.parse(stream, {}, t.object({}));
+    const result = await parser.parse(stream, {}, z.object({}));
     expect(result).toBeUndefined();
   });
 
@@ -356,7 +356,7 @@ describe("ServerBodyParserProvider", () => {
     const result = await parser.parse(
       stream,
       { "content-type": "application/octet-stream" },
-      t.object({}),
+      z.object({}),
     );
     expect(result).toBeUndefined();
   });

package/src/server/core/__tests__/ServerMultipartProvider.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { $action, AlephaServer, ServerProvider } from "alepha/server";
 import { describe, test } from "vitest";
 import { multipartOptions } from "../providers/ServerMultipartProvider.ts";
@@ -6,10 +6,10 @@ import { multipartOptions } from "../providers/ServerMultipartProvider.ts";
 class App {
   upload = $action({
     schema: {
-      body: t.object({
-        file: t.file(),
+      body: z.object({
+        file: z.file(),
       }),
-      response: t.text(),
+      response: z.text(),
     },
     handler: ({ body }) => {
       return `${body.file.name} (${body.file.size}b, ${body.file.type})`;
@@ -52,8 +52,8 @@ describe("ServerMultipartProvider", () => {
     class TextApp {
       upload = $action({
         schema: {
-          body: t.object({ file: t.file() }),
-          response: t.text(),
+          body: z.object({ file: z.file() }),
+          response: z.text(),
         },
         handler: async ({ body }) => body.file.text(),
       });
@@ -78,8 +78,8 @@ describe("ServerMultipartProvider", () => {
     class BufferApp {
       upload = $action({
         schema: {
-          body: t.object({ file: t.file() }),
-          response: t.text(),
+          body: z.object({ file: z.file() }),
+          response: z.text(),
         },
         handler: async ({ body }) => {
           const ab = await body.file.arrayBuffer();
@@ -104,8 +104,8 @@ describe("ServerMultipartProvider", () => {
     class BinaryApp {
       upload = $action({
         schema: {
-          body: t.object({ file: t.file() }),
-          response: t.text(),
+          body: z.object({ file: z.file() }),
+          response: z.text(),
         },
         handler: async ({ body }) => {
           const ab = await body.file.arrayBuffer();
@@ -145,12 +145,12 @@ describe("ServerMultipartProvider", () => {
     class MixedApp {
       upload = $action({
         schema: {
-          body: t.object({
-            name: t.text(),
-            description: t.text(),
-            file: t.file(),
+          body: z.object({
+            name: z.text(),
+            description: z.text(),
+            file: z.file(),
           }),
-          response: t.text(),
+          response: z.text(),
         },
         handler: ({ body }) =>
           `${body.name}: ${body.description} (${body.file.size}b)`,
@@ -177,8 +177,8 @@ describe("ServerMultipartProvider", () => {
     class PathApp {
       upload = $action({
         schema: {
-          body: t.object({ file: t.file() }),
-          response: t.text(),
+          body: z.object({ file: z.file() }),
+          response: z.text(),
         },
         handler: ({ body }) => String(body.file.filepath ?? "none"),
       });
@@ -231,11 +231,11 @@ describe("ServerMultipartProvider - Size Limits", () => {
     class MultiFileApp {
       upload = $action({
         schema: {
-          body: t.object({
-            file1: t.file(),
-            file2: t.file(),
+          body: z.object({
+            file1: z.file(),
+            file2: z.file(),
           }),
-          response: t.text(),
+          response: z.text(),
         },
         handler: () => "ok",
       });
@@ -273,12 +273,12 @@ describe("ServerMultipartProvider - Size Limits", () => {
     class ManyFilesApp {
       upload = $action({
         schema: {
-          body: t.object({
-            file1: t.file(),
-            file2: t.file(),
-            file3: t.file(),
+          body: z.object({
+            file1: z.file(),
+            file2: z.file(),
+            file3: z.file(),
           }),
-          response: t.text(),
+          response: z.text(),
         },
         handler: () => "ok",
       });
@@ -383,14 +383,14 @@ describe("ServerMultipartProvider - Size Limits", () => {
     class TextAndFilesApp {
       upload = $action({
         schema: {
-          body: t.object({
-            field1: t.text(),
-            field2: t.text(),
-            field3: t.text(),
-            file1: t.file(),
-            file2: t.file(),
+          body: z.object({
+            field1: z.text(),
+            field2: z.text(),
+            field3: z.text(),
+            file1: z.file(),
+            file2: z.file(),
           }),
-          response: t.text(),
+          response: z.text(),
         },
         handler: () => "success",
       });

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

@@ -14,7 +14,11 @@ describe("ServerRouterProvider - errorHandler", () => {
   describe("in production mode", () => {
     it("should not leak error details in 500 response", async ({ expect }) => {
       const alepha = Alepha.create({
-        env: { NODE_ENV: "production", SERVER_PORT: 0 },
+        env: {
+          NODE_ENV: "production",
+          SERVER_PORT: 0,
+          APP_SECRET: "test-secret",
+        },
       }).with(TestApp);
 
       await alepha.start();

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

@@ -1,4 +1,4 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, it } from "vitest";
 import { $action, $route, ServerRouterProvider } from "../index.ts";
 
@@ -11,13 +11,13 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       action1 = $action({
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       action2 = $action({
         path: "/posts",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
@@ -41,19 +41,19 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       users = $action({
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       userDetail = $action({
         path: "/users/:id",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       posts = $action({
         path: "/posts",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
@@ -85,13 +85,13 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       users = $action({
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       posts = $action({
         path: "/posts",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
     }
@@ -112,7 +112,7 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       users = $action({
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
     }
@@ -133,13 +133,13 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       apiInfo = $action({
         path: "/api-info",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       apiUsers = $action({
         path: "/api-users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
@@ -166,25 +166,25 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       level1 = $action({
         path: "/v1/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       level2 = $action({
         path: "/v1/users/:id/posts",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       level3 = $action({
         path: "/v1/users/:id/posts/:postId/comments",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       v2 = $action({
         path: "/v2/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
     }
@@ -209,19 +209,19 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       health = $route({
         path: "/health",
-        schema: { response: t.object({ status: t.string() }) },
+        schema: { response: z.object({ status: z.string() }) },
         handler: () => ({ status: "ok" }),
       });
 
       about = $route({
         path: "/about",
-        schema: { response: t.object({ name: t.string() }) },
+        schema: { response: z.object({ name: z.string() }) },
         handler: () => ({ name: "app" }),
       });
 
       users = $action({
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
     }
@@ -240,13 +240,13 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       publicApi = $action({
         path: "/public/info",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       adminApi = $action({
         path: "/admin/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
@@ -276,21 +276,21 @@ describe("ServerRouterProvider - getRoutes", () => {
       getUsers = $action({
         method: "GET",
         path: "/users",
-        schema: { response: t.array(t.object({ id: t.integer() })) },
+        schema: { response: z.array(z.object({ id: z.integer() })) },
         handler: () => [],
       });
 
       createUser = $action({
         method: "POST",
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       updateUser = $action({
         method: "PATCH",
         path: "/users/:id",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
     }
@@ -312,13 +312,13 @@ describe("ServerRouterProvider - getRoutes", () => {
     class TestApp {
       users = $action({
         path: "/users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
 
       users2 = $action({
         path: "/Users",
-        schema: { response: t.object({ id: t.integer() }) },
+        schema: { response: z.object({ id: z.integer() }) },
         handler: () => ({ id: 1 }),
       });
     }

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

@@ -1,13 +1,13 @@
-import { Alepha, t } from "alepha";
+import { Alepha, z } from "alepha";
 import { describe, it } from "vitest";
 import { $action, ServerProvider } from "../index.ts";
 
 class TestApp {
   badResponse = $action({
     schema: {
-      response: t.object({
-        name: t.text(),
-        age: t.integer(),
+      response: z.object({
+        name: z.text(),
+        age: z.integer(),
       }),
     },
     handler: () =>
@@ -25,7 +25,11 @@ describe("ServerRouterProvider - response serialization error", () => {
       expect,
     }) => {
       const alepha = Alepha.create({
-        env: { NODE_ENV: "production", SERVER_PORT: 0 },
+        env: {
+          NODE_ENV: "production",
+          SERVER_PORT: 0,
+          APP_SECRET: "test-secret",
+        },
       }).with(TestApp);
 
       await alepha.start();