alepha 0.14.2 → 0.14.4

package/src/server/static/providers/ServerStaticProvider.ts

@@ -136,6 +136,16 @@ export class ServerStaticProvider {
       const { headers, reply } = request;
       let path = filepath;
 
+      // 01/26 - when calling "/directory", redirect to "/directory/"
+      if (
+        options.path &&
+        options.path === request.url.pathname &&
+        !options.path.endsWith("/")
+      ) {
+        reply.redirect(`${options.path}/`);
+        return;
+      }
+
       const encoding = headers["accept-encoding"];
       if (encoding) {
         if (hasBr && encoding.includes("br")) {

package/src/server/swagger/__tests__/ui.spec.ts

@@ -0,0 +1,52 @@
+import { Alepha, t } from "alepha";
+import { $action, ServerProvider } from "alepha/server";
+import { describe, test } from "vitest";
+import { $swagger } from "../index.ts";
+
+class App {
+  docs = $swagger({
+    info: {
+      title: "Test API",
+      description: "This is a test API",
+      version: "1.0.0",
+    },
+    prefix: "/test",
+    ui: true,
+  });
+
+  hello = $action({
+    schema: {
+      response: t.object({
+        message: t.text(),
+      }),
+    },
+    handler: async () => {
+      return {
+        message: "Hello world",
+      };
+    },
+  });
+}
+
+describe("Swagger UI", () => {
+  const alepha = Alepha.create().with(App);
+  const server = alepha.inject(ServerProvider);
+
+  test("ui", async ({ expect }) => {
+    const html = await fetch(`${server.hostname}/test/`).then((it) =>
+      it.text(),
+    );
+    expect(html).toContain('<div id="swagger-ui"></div>');
+
+    const initializer = await fetch(
+      `${server.hostname}/test/swagger-initializer.js`,
+    ).then((it) => it.text());
+    expect(initializer).toContain("SwaggerUIBundle");
+
+    const json = await fetch(`${server.hostname}/test/json`).then((it) =>
+      it.text(),
+    );
+    expect(json).toContain("Test API");
+    expect(json).toContain("hello");
+  });
+});

package/src/server/swagger/primitives/$swagger.spec.ts

@@ -0,0 +1,193 @@
+import { Alepha, t } from "alepha";
+import { $action } from "alepha/server";
+import { describe, expect, it } from "vitest";
+import { $swagger, ServerSwaggerProvider } from "../index.ts";
+
+class App {
+  internal = $action({
+    hide: true,
+    schema: {
+      response: t.object({
+        message: t.text(),
+      }),
+    },
+    handler: async () => {
+      return {
+        message: "Hello world",
+      };
+    },
+  });
+
+  api = $action({
+    hide: true,
+    schema: {
+      response: t.object({
+        message: t.text(),
+      }),
+    },
+    handler: async () => {
+      return {
+        message: "Hello world",
+      };
+    },
+  });
+
+  text = $action({
+    schema: {
+      response: t.text(),
+    },
+    handler: async () => {
+      return "Hello world";
+    },
+  });
+
+  hello = $action({
+    path: "/hello/:name",
+    name: "hello",
+    description: "Hello world",
+    group: "app",
+    schema: {
+      params: t.object({
+        name: t.text(),
+      }),
+      query: t.object({
+        age: t.optional(t.number()),
+      }),
+      body: t.object({
+        name: t.text(),
+      }),
+      response: t.object(
+        {
+          message: t.text(),
+        },
+        {
+          title: "HelloResponse",
+          description: "Hello response",
+        },
+      ),
+    },
+    handler: async (req) => {
+      return {
+        message: `Hello ${req.body.name}`,
+      };
+    },
+  });
+
+  docs = $swagger({
+    info: {
+      title: "My API",
+      version: "1.0.0",
+    },
+    ui: false,
+  });
+}
+
+const alepha = Alepha.create().with(App);
+
+describe("$swagger", () => {
+  it("should generate OpenAPI spec from actions", () => {
+    const swagger = alepha.inject(ServerSwaggerProvider).json;
+
+    expect(swagger).toEqual({
+      openapi: "3.0.0",
+      info: {
+        title: "My API",
+        version: "1.0.0",
+      },
+      paths: {
+        "/api/hello/{name}": {
+          post: {
+            operationId: "hello",
+            parameters: [
+              {
+                in: "query",
+                name: "age",
+                required: false,
+                schema: {
+                  type: "number",
+                },
+              },
+              {
+                in: "path",
+                name: "name",
+                required: true,
+                schema: {
+                  maxLength: 255,
+                  type: "string",
+                },
+              },
+            ],
+            description: "Hello world",
+            tags: ["app"],
+            responses: {
+              "200": {
+                description: "",
+                content: {
+                  "application/json": {
+                    schema: {
+                      $ref: "#/components/schemas/HelloResponse",
+                    },
+                  },
+                },
+              },
+            },
+            requestBody: {
+              required: true,
+              content: {
+                "application/json": {
+                  schema: {
+                    additionalProperties: false,
+                    type: "object",
+                    properties: {
+                      name: {
+                        maxLength: 255,
+                        type: "string",
+                      },
+                    },
+                    required: ["name"],
+                  },
+                },
+              },
+            },
+          },
+        },
+        "/api/text": {
+          get: {
+            operationId: "text",
+            responses: {
+              "200": {
+                content: {
+                  "text/plain": {
+                    schema: {
+                      maxLength: 255,
+                      type: "string",
+                    },
+                  },
+                },
+                description: "",
+              },
+            },
+            tags: ["App"],
+          },
+        },
+      },
+      components: {
+        schemas: {
+          HelloResponse: {
+            additionalProperties: false,
+            description: "Hello response",
+            properties: {
+              message: {
+                maxLength: 255,
+                type: "string",
+              },
+            },
+            required: ["message"],
+            title: "HelloResponse",
+            type: "object",
+          },
+        },
+      },
+    });
+  });
+});

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

@@ -79,17 +79,11 @@ export class ServerSwaggerProvider {
         return;
       }
 
-      this.json = await this.createSwagger(options);
+      this.json = await this.setupSwaggerPlugin(options);
     },
   });
 
-  public async createSwagger(
-    options: SwaggerPrimitiveOptions,
-  ): Promise<OpenApiDocument | undefined> {
-    if (options.disabled) {
-      return;
-    }
-
+  public generateSwaggerDoc(options: SwaggerPrimitiveOptions): OpenApiDocument {
     const json = this.configureOpenApi(
       this.alepha.primitives($action),
       options,
@@ -99,12 +93,26 @@ export class ServerSwaggerProvider {
       options.rewrite(json);
     }
 
+    return json;
+  }
+
+  protected async setupSwaggerPlugin(
+    options: SwaggerPrimitiveOptions,
+  ): Promise<OpenApiDocument | undefined> {
+    if (options.disabled) {
+      return;
+    }
+
+    const json = this.generateSwaggerDoc(options);
+
     const prefix = options.prefix ?? "/docs";
 
     this.configureSwaggerApi(prefix, json);
 
     if (options.ui !== false) {
       await this.configureSwaggerUi(prefix, options);
+    } else {
+      this.log.info(`Swagger API available at ${prefix}/json`);
     }
 
     return json;
@@ -352,7 +360,6 @@ export class ServerSwaggerProvider {
       },
       handler: () => json,
     });
-    this.log.info(`Swagger API available at ${prefix}/json`);
   }
 
   protected async configureSwaggerUi(
@@ -418,9 +425,9 @@ window.onload = function() {
       },
     });
 
-    this.log.info(
-      `Swagger UI available at ${this.serverProvider.hostname}${prefix}/`,
-    );
+    this.log.info("SwaggerUI OK", {
+      url: `${this.serverProvider.hostname}${prefix}`,
+    });
   }
 
   protected async getAssetPath(

package/src/sms/primitives/$sms.spec.ts

@@ -0,0 +1,165 @@
+import { Alepha } from "alepha";
+import { describe, test } from "vitest";
+import { $sms, MemorySmsProvider } from "../index.ts";
+
+describe("$sms", () => {
+  test("should send SMS using primitive", async ({ expect }) => {
+    class TestService {
+      readonly welcomeSms = $sms({ name: "welcome" });
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.welcomeSms.send({
+      to: "+1234567890",
+      message: "Hello World!",
+    });
+
+    const provider = alepha.inject(MemorySmsProvider);
+    const messages = provider.records;
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0].to).toBe("+1234567890");
+    expect(messages[0].message).toBe("Hello World!");
+  });
+
+  test("should send SMS to multiple recipients", async ({ expect }) => {
+    class TestService {
+      readonly notificationSms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.notificationSms.send({
+      to: ["+1234567890", "+0987654321"],
+      message: "Important notification",
+    });
+
+    const provider = alepha.inject(MemorySmsProvider);
+    const messages = provider.records;
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0].to).toBe("+1234567890");
+    expect(messages[1].to).toBe("+0987654321");
+  });
+
+  test("should use memory provider by default", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.sms.send({
+      to: "+1234567890",
+      message: "Test",
+    });
+
+    const provider = alepha.inject(MemorySmsProvider);
+    expect(provider.records).toHaveLength(1);
+  });
+
+  test("should use explicit memory provider", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms({ provider: "memory" });
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+    await alepha.start();
+
+    await service.sms.send({
+      to: "+1234567890",
+      message: "Test",
+    });
+
+    const provider = alepha.inject(MemorySmsProvider);
+    expect(provider.records).toHaveLength(1);
+  });
+
+  test("should emit sms:sending and sms:sent events", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms({ name: "test-sms" });
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+
+    const sendingEvents: any[] = [];
+    const sentEvents: any[] = [];
+
+    alepha.events.on("sms:sending", (event) => {
+      sendingEvents.push(event);
+    });
+
+    alepha.events.on("sms:sent", (event) => {
+      sentEvents.push(event);
+    });
+
+    await alepha.start();
+
+    await service.sms.send({
+      to: "+1234567890",
+      message: "Test message",
+    });
+
+    expect(sendingEvents).toHaveLength(1);
+    expect(sendingEvents[0].to).toBe("+1234567890");
+    expect(sendingEvents[0].template).toBe("test-sms");
+
+    expect(sentEvents).toHaveLength(1);
+    expect(sentEvents[0].to).toBe("+1234567890");
+    expect(sentEvents[0].template).toBe("test-sms");
+  });
+
+  test("should abort SMS sending via hook", async ({ expect }) => {
+    class TestService {
+      readonly sms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+
+    alepha.events.on("sms:sending", (event) => {
+      event.abort();
+    });
+
+    await alepha.start();
+
+    await expect(
+      service.sms.send({
+        to: "+1234567890",
+        message: "Test",
+      }),
+    ).rejects.toThrowError("SMS sending aborted by hook");
+  });
+
+  test("should use property key as default name", async ({ expect }) => {
+    class TestService {
+      readonly welcomeSms = $sms();
+    }
+
+    const alepha = Alepha.create();
+    const service = alepha.inject(TestService);
+
+    let capturedTemplate = "";
+    alepha.events.on("sms:sending", (event) => {
+      capturedTemplate = event.template;
+    });
+
+    await alepha.start();
+
+    await service.welcomeSms.send({
+      to: "+1234567890",
+      message: "Test",
+    });
+
+    expect(capturedTemplate).toBe("welcomeSms");
+  });
+});

package/src/sms/providers/LocalSmsProvider.spec.ts

@@ -0,0 +1,224 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { SmsError } from "../errors/SmsError.ts";
+import { LocalSmsProvider } from "../providers/LocalSmsProvider.ts";
+
+// Mock fs and path modules
+vi.mock("node:fs/promises");
+vi.mock("node:path");
+
+// Mock logger
+vi.mock("alepha/logger", () => ({
+  $logger: () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    error: vi.fn(),
+  }),
+}));
+
+const mockedFs = vi.mocked(fs);
+const mockedPath = vi.mocked(path);
+
+describe("LocalSmsProvider", () => {
+  let provider: LocalSmsProvider;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Setup default path.join mock
+    mockedPath.join.mockImplementation((...args) => args.join("/"));
+  });
+
+  describe("send", () => {
+    beforeEach(() => {
+      provider = new LocalSmsProvider({ directory: "test-sms" });
+    });
+
+    test("should successfully send SMS to local file", async () => {
+      mockedFs.mkdir.mockResolvedValue(undefined);
+      mockedFs.writeFile.mockResolvedValue();
+
+      const to = "+1234567890";
+      const message = "Test message";
+
+      await provider.send({
+        to,
+        message,
+      });
+
+      expect(mockedFs.mkdir).toHaveBeenCalledWith("test-sms", {
+        recursive: true,
+      });
+      expect(mockedFs.writeFile).toHaveBeenCalledWith(
+        expect.stringContaining("+1234567890"),
+        expect.stringContaining(message),
+        "utf8",
+      );
+    });
+
+    test("should create proper filename with sanitized phone and timestamp", async () => {
+      mockedFs.mkdir.mockResolvedValue(undefined);
+      mockedFs.writeFile.mockResolvedValue();
+
+      const to = "+1 (234) 567-8900";
+      const message = "Test message";
+
+      // Mock Date to have predictable timestamp
+      const mockDate = new Date("2023-01-01T12:00:00.000Z");
+      vi.setSystemTime(mockDate);
+
+      await provider.send({
+        to,
+        message,
+      });
+
+      expect(mockedPath.join).toHaveBeenCalledWith(
+        "test-sms",
+        "+1__234__567_8900+2023-01-01T12-00-00-000Z.txt",
+      );
+
+      vi.useRealTimers();
+    });
+
+    test("should sanitize special characters in phone number", async () => {
+      mockedFs.mkdir.mockResolvedValue(undefined);
+      mockedFs.writeFile.mockResolvedValue();
+
+      const to = "+1-234-567-8900 ext. 123";
+      const message = "Test message";
+
+      await provider.send({
+        to,
+        message,
+      });
+
+      expect(mockedPath.join).toHaveBeenCalledWith(
+        "test-sms",
+        expect.stringMatching(/\+1_234_567_8900______123\+.+\.txt/),
+      );
+    });
+
+    test("should create proper text content", async () => {
+      mockedFs.mkdir.mockResolvedValue(undefined);
+      mockedFs.writeFile.mockResolvedValue();
+
+      const to = "+1234567890";
+      const message = "Test message with content";
+
+      await provider.send({
+        to,
+        message,
+      });
+
+      const writeCall = mockedFs.writeFile.mock.calls[0];
+      const textContent = writeCall[1] as string;
+
+      expect(textContent).toContain("SMS Message");
+      expect(textContent).toContain("+1234567890");
+      expect(textContent).toContain("Test message with content");
+      expect(textContent).toContain("Sent:");
+    });
+
+    test("should throw SmsError when mkdir fails", async () => {
+      const mkdirError = new Error("Permission denied");
+      mockedFs.mkdir.mockRejectedValue(mkdirError);
+
+      const to = "+1234567890";
+      const message = "Test message";
+
+      await expect(
+        provider.send({
+          to,
+          message,
+        }),
+      ).rejects.toThrow(SmsError);
+      await expect(
+        provider.send({
+          to,
+          message,
+        }),
+      ).rejects.toThrow("Failed to save SMS to local file: Permission denied");
+    });
+
+    test("should throw SmsError when writeFile fails", async () => {
+      mockedFs.mkdir.mockResolvedValue(undefined);
+      const writeError = new Error("Disk full");
+      mockedFs.writeFile.mockRejectedValue(writeError);
+
+      const to = "+1234567890";
+      const message = "Test message";
+
+      await expect(
+        provider.send({
+          to,
+          message,
+        }),
+      ).rejects.toThrow(SmsError);
+      await expect(
+        provider.send({
+          to,
+          message,
+        }),
+      ).rejects.toThrow("Failed to save SMS to local file: Disk full");
+    });
+
+    test("should handle non-Error exceptions", async () => {
+      mockedFs.mkdir.mockResolvedValue(undefined);
+      mockedFs.writeFile.mockRejectedValue("String error");
+
+      const to = "+1234567890";
+      const message = "Test message";
+
+      await expect(
+        provider.send({
+          to,
+          message,
+        }),
+      ).rejects.toThrow(SmsError);
+      await expect(
+        provider.send({
+          to,
+          message,
+        }),
+      ).rejects.toThrow("Failed to save SMS to local file: String error");
+    });
+  });
+
+  describe("createSmsText", () => {
+    beforeEach(() => {
+      provider = new LocalSmsProvider();
+    });
+
+    test("should create proper text structure", () => {
+      const mockDate = new Date("2023-01-01T12:00:00.000Z");
+      vi.setSystemTime(mockDate);
+
+      const to = "+1234567890";
+      const message = "Test message";
+
+      const text = provider.createSmsText({
+        to,
+        message,
+      });
+
+      expect(text).toContain("SMS Message");
+      expect(text).toContain("+1234567890");
+      expect(text).toContain("Test message");
+      expect(text).toContain("2023-01-01T12:00:00.000Z");
+
+      vi.useRealTimers();
+    });
+
+    test("should handle multiline messages", () => {
+      const to = "+1234567890";
+      const message = "Line 1\nLine 2\nLine 3";
+
+      const text = provider.createSmsText({
+        to,
+        message,
+      });
+
+      expect(text).toContain("Line 1\nLine 2\nLine 3");
+    });
+  });
+});