alepha 0.19.1 → 0.19.3

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>>();