alepha 0.19.1 → 0.19.2

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

@@ -1,7 +1,7 @@
 import { Readable } from "node:stream";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
 import type { TSchema } from "alepha";
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { HttpError } from "../errors/HttpError.ts";
 
@@ -42,7 +42,7 @@ declare module "alepha" {
 export class ServerBodyParserProvider {
   protected readonly alepha = $inject(Alepha);
   protected readonly log = $logger();
-  protected readonly options = $use(bodyParserOptions);
+  protected readonly options = $state(bodyParserOptions);
 
   public readonly onRequest = $hook({
     on: "server:onRequest",
@@ -99,14 +99,20 @@ export class ServerBodyParserProvider {
       }
 
       if (route.schema?.body) {
-        const contentLength = request.headers["content-length"];
-        if (contentLength) {
-          const size = Number.parseInt(contentLength, 10);
-          if (!Number.isNaN(size) && size > this.options.limit) {
-            throw new HttpError({
-              status: 413,
-              message: "Request body size limit exceeded",
-            });
+        const contentType = request.headers["content-type"] ?? "";
+
+        // Skip body size check for multipart requests — ServerMultipartProvider
+        // handles its own limits (multipartOptions.limit / fileLimit).
+        if (!contentType.startsWith("multipart/")) {
+          const contentLength = request.headers["content-length"];
+          if (contentLength) {
+            const size = Number.parseInt(contentLength, 10);
+            if (!Number.isNaN(size) && size > this.options.limit) {
+              throw new HttpError({
+                status: 413,
+                message: "Request body size limit exceeded",
+              });
+            }
           }
         }
 
@@ -260,12 +266,14 @@ export class ServerBodyParserProvider {
     let totalLength = 0;
 
     const reader = stream.getReader();
+    let needsCancel = true;
 
     try {
       while (true) {
         const { done, value } = await reader.read();
 
         if (done) {
+          needsCancel = false;
           break;
         }
 
@@ -277,8 +285,6 @@ export class ServerBodyParserProvider {
               `Body size limit exceeded: ${totalLength} > ${limit}`,
             );
 
-            await reader.cancel();
-
             throw new HttpError({
               status: 413,
               message: "Request body size limit exceeded",
@@ -303,6 +309,9 @@ export class ServerBodyParserProvider {
         combined.byteLength,
       );
     } finally {
+      if (needsCancel) {
+        await reader.cancel().catch(() => {});
+      }
       reader.releaseLock();
     }
   }

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

@@ -2,7 +2,7 @@ import { Readable, type Transform } from "node:stream";
 import { ReadableStream } from "node:stream/web";
 import { promisify } from "node:util";
 import * as zlib from "node:zlib";
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 import type { ServerResponse } from "alepha/server";
 
 const gzip = promisify(zlib.gzip);
@@ -77,7 +77,7 @@ export class ServerCompressProvider {
   };
 
   protected readonly alepha = $inject(Alepha);
-  protected readonly options = $use(compressOptions);
+  protected readonly options = $state(compressOptions);
 
   public readonly onResponse = $hook({
     on: "server:onResponse",

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

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -102,7 +102,7 @@ export class ServerHelmetProvider {
   /**
    * The configuration options loaded from the atom.
    */
-  protected readonly options = $use(helmetOptions);
+  protected readonly options = $state(helmetOptions);
 
   protected defaultCspDirectives(): CspDirectives {
     return {

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

@@ -3,7 +3,7 @@ import {
   $atom,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   type FileLike,
   isTypeFile,
@@ -57,7 +57,7 @@ declare module "alepha" {
 export class ServerMultipartProvider {
   protected readonly alepha = $inject(Alepha);
   protected readonly log = $logger();
-  protected readonly options = $use(multipartOptions);
+  protected readonly options = $state(multipartOptions);
 
   public readonly onRequest = $hook({
     on: "server:onRequest",

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

@@ -310,11 +310,7 @@ export class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     if (responseKind === "text") {
       reply.body = String(reply.body);
       // Detect HTML responses (starts with <!DOCTYPE html>)
-      if (
-        reply.body.length > 15 &&
-        reply.body.charCodeAt(0) === 60 &&
-        reply.body.startsWith("<!DOCTYPE html>")
-      ) {
+      if (reply.body.startsWith("<!DOCTYPE html>")) {
         headers["content-type"] ??= "text/html; charset=UTF-8";
       } else {
         headers["content-type"] ??= "text/plain";

package/src/server/cors/{primitives → __tests__}/$cors.spec.ts

@@ -2,7 +2,7 @@ import { $pipeline, Alepha } from "alepha";
 import { AlephaServer } from "alepha/server";
 import { describe, test } from "vitest";
 import { AlephaServerCors } from "../index.ts";
-import { $cors } from "./$cors.ts";
+import { $cors } from "../primitives/$cors.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // $cors — core behavior

package/src/server/cors/providers/ServerCorsProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { ServerRouterProvider } from "alepha/server";
 
@@ -69,7 +69,7 @@ export interface CorsRegistration extends Partial<CorsOptions> {
 export class ServerCorsProvider {
   protected readonly log = $logger();
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);
-  protected readonly globalOptions = $use(corsOptions);
+  protected readonly globalOptions = $state(corsOptions);
 
   /**
    * Registered CORS configurations with their path patterns

package/src/server/links/{services → __tests__}/BatchCollector.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { describe, it } from "vitest";
-import { BatchCollector } from "./BatchCollector.ts";
+import { BatchCollector } from "../services/BatchCollector.ts";
 
 describe("BatchCollector", () => {
   it("should deduplicate identical entries", ({ expect }) => {

package/src/server/links/providers/LinkProvider.ts

@@ -1,4 +1,4 @@
-import { $inject, $use, Alepha, AlephaError, type Async, t } from "alepha";
+import { $inject, $state, Alepha, AlephaError, type Async, t } from "alepha";
 import { $logger } from "alepha/logger";
 import type { SecureOptions } from "alepha/security";
 import {
@@ -50,7 +50,7 @@ export class LinkProvider {
   // Browser-only: batch collector for coalescing multiple calls
   protected batchCollector?: BatchCollector;
 
-  protected readonly options = $use(linkOptionsAtom);
+  protected readonly options = $state(linkOptionsAtom);
 
   /**
    * Get applicative links registered on the server.

package/src/server/links/providers/RemotePrimitiveProvider.ts

@@ -1,4 +1,4 @@
-import { $hook, $inject, $pipeline, $use, Alepha, AlephaError } from "alepha";
+import { $hook, $inject, $pipeline, $state, Alepha, AlephaError } from "alepha";
 import { $logger } from "alepha/logger";
 import { $retry } from "alepha/retry";
 import type { ServiceAccountPrimitive } from "alepha/security";
@@ -12,7 +12,7 @@ import {
 import { LinkProvider } from "./LinkProvider.ts";
 
 export class RemotePrimitiveProvider {
-  protected readonly serverApi = $use(serverApiOptions);
+  protected readonly serverApi = $state(serverApiOptions);
   protected readonly alepha = $inject(Alepha);
   protected readonly proxyProvider = $inject(ServerProxyProvider);
   protected readonly linkProvider = $inject(LinkProvider);

package/src/server/links/providers/ServerLinksProvider.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { $hook, $inject, $use, Alepha, AlephaError, t } from "alepha";
+import { $hook, $inject, $state, Alepha, AlephaError, t } from "alepha";
 import { $logger } from "alepha/logger";
 import type { SecurityProvider, UserAccountToken } from "alepha/security";
 import {
@@ -17,7 +17,7 @@ import { type HttpClientLink, LinkProvider } from "./LinkProvider.ts";
 import { RemotePrimitiveProvider } from "./RemotePrimitiveProvider.ts";
 
 export class ServerLinksProvider {
-  protected readonly serverApi = $use(serverApiOptions);
+  protected readonly serverApi = $state(serverApiOptions);
   protected readonly alepha = $inject(Alepha);
   protected readonly linkProvider = $inject(LinkProvider);
   protected readonly remoteProvider = $inject(RemotePrimitiveProvider);

package/src/server/rate-limit/{primitives → __tests__}/$rateLimit.spec.ts

@@ -3,7 +3,7 @@ import { AlephaCache } from "alepha/cache";
 import { AlephaServer, HttpError, type ServerRequest } from "alepha/server";
 import { describe, test } from "vitest";
 import { AlephaServerRateLimit } from "../index.ts";
-import { $rateLimit } from "./$rateLimit.ts";
+import { $rateLimit } from "../primitives/$rateLimit.ts";
 
 // -----------------------------------------------------------------------------------------------------------------
 // Test helpers

package/src/server/rate-limit/providers/ServerRateLimitProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, type Static, t } from "alepha";
 import { CacheProvider } from "alepha/cache";
 import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
@@ -74,7 +74,7 @@ export class ServerRateLimitProvider {
   protected readonly dateTime = $inject(DateTimeProvider);
   protected readonly serverRouterProvider = $inject(ServerRouterProvider);
   protected readonly cacheProvider = $inject(CacheProvider);
-  protected readonly globalOptions = $use(rateLimitOptions);
+  protected readonly globalOptions = $state(rateLimitOptions);
 
   protected static readonly CACHE_NAME = "rate-limit";
 

package/src/server/swagger/providers/ServerSwaggerProvider.ts

@@ -4,7 +4,7 @@ import {
   $atom,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   isTypeFile,
   type Static,
@@ -64,7 +64,7 @@ export class ServerSwaggerProvider {
   protected readonly serverProvider = $inject(ServerProvider);
   protected readonly alepha = $inject(Alepha);
   protected readonly log = $logger();
-  protected readonly options = $use(swaggerOptions);
+  protected readonly options = $state(swaggerOptions);
   protected readonly fs = $inject(FileSystemProvider);
 
   public json?: OpenApiDocument;

package/src/sms/{providers → __tests__}/LocalSmsProvider.spec.ts

@@ -1,14 +1,14 @@
 import { Alepha } from "alepha";
 import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/system";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { SmsError } from "../errors/SmsError.ts";
-import { LocalSmsProvider } from "./LocalSmsProvider.ts";
+import { LocalSmsProvider } from "../providers/LocalSmsProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 describe("LocalSmsProvider", () => {
   describe("send", () => {
-    test("should successfully send SMS to local file", async () => {
+    it("should successfully send SMS to local file", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -29,10 +29,14 @@ describe("LocalSmsProvider", () => {
 
       expect(memoryFs.writeFileCalls).toHaveLength(1);
       expect(memoryFs.writeFileCalls[0].path).toContain("+1234567890");
-      expect(memoryFs.writeFileCalls[0].data).toContain("Test message");
+
+      const written = JSON.parse(memoryFs.writeFileCalls[0].data as string);
+      expect(written.to).toBe("+1234567890");
+      expect(written.message).toBe("Test message");
+      expect(written.sentAt).toBeDefined();
     });
 
-    test("should create proper filename with sanitized phone and timestamp", async () => {
+    it("should create proper filename with sanitized phone and timestamp", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -54,13 +58,13 @@ describe("LocalSmsProvider", () => {
       expect(memoryFs.joinCalls).toHaveLength(1);
       expect(memoryFs.joinCalls[0]).toEqual([
         "node_modules/.alepha/sms",
-        "+1__234__567_8900+2023-01-01T12-00-00-000Z.txt",
+        "+1__234__567_8900,2023-01-01T12-00-00-000Z.sms.json",
       ]);
 
       vi.useRealTimers();
     });
 
-    test("should sanitize special characters in phone number", async () => {
+    it("should sanitize special characters in phone number", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -77,11 +81,11 @@ describe("LocalSmsProvider", () => {
 
       expect(memoryFs.joinCalls).toHaveLength(1);
       expect(memoryFs.joinCalls[0][1]).toMatch(
-        /\+1_234_567_8900______123\+.+\.txt/,
+        /\+1_234_567_8900______123,.+\.sms\.json/,
       );
     });
 
-    test("should create proper text content", async () => {
+    it("should create proper JSON content", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -91,20 +95,23 @@ describe("LocalSmsProvider", () => {
       const memoryFs = alepha.inject(MemoryFileSystemProvider);
       await alepha.start();
 
+      const mockDate = new Date("2023-01-01T12:00:00.000Z");
+      vi.setSystemTime(mockDate);
+
       await provider.send({
         to: "+1234567890",
         message: "Test message with content",
       });
 
-      const textContent = memoryFs.writeFileCalls[0].data;
+      const written = JSON.parse(memoryFs.writeFileCalls[0].data as string);
+      expect(written.to).toBe("+1234567890");
+      expect(written.message).toBe("Test message with content");
+      expect(written.sentAt).toBe("2023-01-01T12:00:00.000Z");
 
-      expect(textContent).toContain("SMS Message");
-      expect(textContent).toContain("+1234567890");
-      expect(textContent).toContain("Test message with content");
-      expect(textContent).toContain("Sent:");
+      vi.useRealTimers();
     });
 
-    test("should throw SmsError when mkdir fails", async () => {
+    it("should throw SmsError when mkdir fails", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -131,7 +138,7 @@ describe("LocalSmsProvider", () => {
       ).rejects.toThrow("Failed to save SMS to local file: Permission denied");
     });
 
-    test("should throw SmsError when writeFile fails", async () => {
+    it("should throw SmsError when writeFile fails", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -158,7 +165,7 @@ describe("LocalSmsProvider", () => {
       ).rejects.toThrow("Failed to save SMS to local file: Disk full");
     });
 
-    test("should handle non-Error exceptions", async () => {
+    it("should handle non-Error exceptions", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -179,7 +186,7 @@ describe("LocalSmsProvider", () => {
       ).rejects.toThrow(SmsError);
     });
 
-    test("should handle multiple recipients", async () => {
+    it("should handle multiple recipients", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -199,7 +206,7 @@ describe("LocalSmsProvider", () => {
       expect(memoryFs.writeFileCalls[1].path).toContain("+2222222222");
     });
 
-    test("should use custom directory when provided", async () => {
+    it("should use custom directory when provided", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -225,7 +232,7 @@ describe("LocalSmsProvider", () => {
     });
   });
 
-  describe("createSmsText", () => {
+  describe("createSmsJson", () => {
     let provider: LocalSmsProvider;
 
     beforeEach(async () => {
@@ -237,30 +244,29 @@ describe("LocalSmsProvider", () => {
       await alepha.start();
     });
 
-    test("should create proper text structure", () => {
+    it("should create proper JSON structure", () => {
       const mockDate = new Date("2023-01-01T12:00:00.000Z");
       vi.setSystemTime(mockDate);
 
-      const text = provider.createSmsText({
+      const result = provider.createSmsJson({
         to: "+1234567890",
         message: "Test message",
       });
 
-      expect(text).toContain("SMS Message");
-      expect(text).toContain("+1234567890");
-      expect(text).toContain("Test message");
-      expect(text).toContain("2023-01-01T12:00:00.000Z");
+      expect(result.to).toBe("+1234567890");
+      expect(result.message).toBe("Test message");
+      expect(result.sentAt).toBe("2023-01-01T12:00:00.000Z");
 
       vi.useRealTimers();
     });
 
-    test("should handle multiline messages", () => {
-      const text = provider.createSmsText({
+    it("should handle multiline messages", () => {
+      const result = provider.createSmsJson({
         to: "+1234567890",
         message: "Line 1\nLine 2\nLine 3",
       });
 
-      expect(text).toContain("Line 1\nLine 2\nLine 3");
+      expect(result.message).toBe("Line 1\nLine 2\nLine 3");
     });
   });
 });

package/src/sms/providers/LocalSmsProvider.ts

@@ -34,21 +34,14 @@ export class LocalSmsProvider implements SmsProvider {
       // Ensure directory exists
       await this.fs.mkdir(this.directory, { recursive: true });
 
-      // Create filename: phone+date
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
       for (const recipient of Array.isArray(to) ? to : [to]) {
         const sanitizedPhone = recipient.replace(/[^0-9+]/g, "_");
-        const filename = `${sanitizedPhone}+${timestamp}.txt`;
+        const filename = `${sanitizedPhone},${timestamp}.sms.json`;
         const filepath = this.fs.join(this.directory, filename);
 
-        // Create text content
-        const textContent = this.createSmsText({
-          to: recipient,
-          message,
-        });
-
-        // Write to file
-        await this.fs.writeFile(filepath, textContent);
+        const content = this.createSmsJson({ to: recipient, message });
+        await this.fs.writeFile(filepath, JSON.stringify(content, null, 2));
 
         this.log.info("SMS saved to local file", { filepath, to });
       }
@@ -59,19 +52,15 @@ export class LocalSmsProvider implements SmsProvider {
     }
   }
 
-  public createSmsText(options: { to: string; message: string }): string {
-    const { to, message } = options;
-    const timestamp = new Date().toISOString();
-
-    return `SMS Message
-===========
-
-Sent: ${timestamp}
-To: ${to}
-
-Message:
---------
-${message}
-`;
+  public createSmsJson(options: { to: string; message: string }): {
+    to: string;
+    message: string;
+    sentAt: string;
+  } {
+    return {
+      to: options.to,
+      message: options.message,
+      sentAt: new Date().toISOString(),
+    };
   }
 }

package/src/system/{providers → __tests__}/MemoryFileSystemProvider.spec.ts

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { beforeEach, describe, expect, it } from "vitest";
-import { MemoryFileSystemProvider } from "./MemoryFileSystemProvider.ts";
+import { MemoryFileSystemProvider } from "../providers/MemoryFileSystemProvider.ts";
 
 describe("MemoryFileSystemProvider", () => {
   let alepha: Alepha;

package/src/system/{providers → __tests__}/MemoryShellProvider.spec.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { MemoryShellProvider } from "./MemoryShellProvider.ts";
+import { MemoryShellProvider } from "../providers/MemoryShellProvider.ts";
 
 describe("MemoryShellProvider", () => {
   let shell: MemoryShellProvider;

package/src/topic/redis/providers/RedisTopicProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $hook, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $hook, $inject, $state, Alepha, type Static, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { RedisProvider, RedisSubscriberProvider } from "alepha/redis";
 import {
@@ -38,7 +38,7 @@ declare module "alepha" {
 // ---------------------------------------------------------------------------------------------------------------------
 
 export class RedisTopicProvider extends TopicProvider {
-  protected readonly options = $use(redisTopicOptions);
+  protected readonly options = $state(redisTopicOptions);
   protected readonly alepha = $inject(Alepha);
   protected readonly redisProvider = $inject(RedisProvider);
   protected readonly redisSubscriberProvider = $inject(RedisSubscriberProvider);

package/src/websocket/{services → __tests__}/RoomManager.spec.ts

@@ -1,7 +1,7 @@
 import { Alepha } from "alepha";
 import { describe, expect, it } from "vitest";
 import { AlephaWebSocket } from "../index.ts";
-import { RoomManager } from "./RoomManager.ts";
+import { RoomManager } from "../services/RoomManager.ts";
 
 describe("RoomManager", () => {
   const createRoomManager = () => {

package/src/websocket/providers/NodeWebSocketServerProvider.ts

@@ -3,7 +3,7 @@ import {
   $atom,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   AlephaError,
   type Static,
@@ -58,7 +58,7 @@ export class NodeWebSocketServerProvider extends WebSocketServerProvider {
   protected readonly roomManager = $inject(RoomManager);
   protected readonly topicService = $inject(WebSocketTopicService);
   protected readonly log = $logger();
-  protected readonly wsOptions = $use(websocketOptions);
+  protected readonly wsOptions = $state(websocketOptions);
 
   protected wss?: WebSocketServer;
   protected endpoints = new Map<string, WebSocketPrimitiveOptions<any, any>>();

package/tsconfig.base.json

@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "types": ["node", "bun"],
     "module": "nodenext",
     "target": "esnext",
     "strict": true,