alepha 0.14.3 → 0.15.0

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

@@ -80,10 +80,6 @@ export class ServerSwaggerProvider {
       }
 
       this.json = await this.setupSwaggerPlugin(options);
-
-      if (this.json) {
-        this.log.info("Swagger documentation generated successfully.");
-      }
     },
   });
 
@@ -115,6 +111,8 @@ export class ServerSwaggerProvider {
 
     if (options.ui !== false) {
       await this.configureSwaggerUi(prefix, options);
+    } else {
+      this.log.info(`Swagger API available at ${prefix}/json`);
     }
 
     return json;
@@ -362,7 +360,6 @@ export class ServerSwaggerProvider {
       },
       handler: () => json,
     });
-    this.log.info(`Swagger API available at ${prefix}/json`);
   }
 
   protected async configureSwaggerUi(
@@ -428,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/providers/LocalSmsProvider.spec.ts

@@ -1,117 +1,102 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
+import { Alepha } from "alepha";
+import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/file";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { SmsError } from "../errors/SmsError.ts";
-import { LocalSmsProvider } from "../providers/LocalSmsProvider.ts";
+import { LocalSmsProvider } from "./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 alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
 
-      const to = "+1234567890";
-      const message = "Test message";
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
       await provider.send({
-        to,
-        message,
+        to: "+1234567890",
+        message: "Test message",
       });
 
-      expect(mockedFs.mkdir).toHaveBeenCalledWith("test-sms", {
-        recursive: true,
-      });
-      expect(mockedFs.writeFile).toHaveBeenCalledWith(
-        expect.stringContaining("+1234567890"),
-        expect.stringContaining(message),
-        "utf8",
-      );
+      expect(memoryFs.mkdirCalls).toHaveLength(1);
+      expect(memoryFs.mkdirCalls[0].path).toBe("node_modules/.alepha/sms");
+      expect(memoryFs.mkdirCalls[0].options).toEqual({ recursive: true });
+
+      expect(memoryFs.writeFileCalls).toHaveLength(1);
+      expect(memoryFs.writeFileCalls[0].path).toContain("+1234567890");
+      expect(memoryFs.writeFileCalls[0].data).toContain("Test message");
     });
 
     test("should create proper filename with sanitized phone and timestamp", async () => {
-      mockedFs.mkdir.mockResolvedValue(undefined);
-      mockedFs.writeFile.mockResolvedValue();
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
 
-      const to = "+1 (234) 567-8900";
-      const message = "Test message";
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
       // Mock Date to have predictable timestamp
       const mockDate = new Date("2023-01-01T12:00:00.000Z");
       vi.setSystemTime(mockDate);
 
       await provider.send({
-        to,
-        message,
+        to: "+1 (234) 567-8900",
+        message: "Test message",
       });
 
-      expect(mockedPath.join).toHaveBeenCalledWith(
-        "test-sms",
+      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",
-      );
+      ]);
 
       vi.useRealTimers();
     });
 
     test("should sanitize special characters in phone number", async () => {
-      mockedFs.mkdir.mockResolvedValue(undefined);
-      mockedFs.writeFile.mockResolvedValue();
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
 
-      const to = "+1-234-567-8900 ext. 123";
-      const message = "Test message";
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
       await provider.send({
-        to,
-        message,
+        to: "+1-234-567-8900 ext. 123",
+        message: "Test message",
       });
 
-      expect(mockedPath.join).toHaveBeenCalledWith(
-        "test-sms",
-        expect.stringMatching(/\+1_234_567_8900______123\+.+\.txt/),
+      expect(memoryFs.joinCalls).toHaveLength(1);
+      expect(memoryFs.joinCalls[0][1]).toMatch(
+        /\+1_234_567_8900______123\+.+\.txt/,
       );
     });
 
     test("should create proper text content", async () => {
-      mockedFs.mkdir.mockResolvedValue(undefined);
-      mockedFs.writeFile.mockResolvedValue();
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
 
-      const to = "+1234567890";
-      const message = "Test message with content";
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
       await provider.send({
-        to,
-        message,
+        to: "+1234567890",
+        message: "Test message with content",
       });
 
-      const writeCall = mockedFs.writeFile.mock.calls[0];
-      const textContent = writeCall[1] as string;
+      const textContent = memoryFs.writeFileCalls[0].data;
 
       expect(textContent).toContain("SMS Message");
       expect(textContent).toContain("+1234567890");
@@ -120,85 +105,145 @@ describe("LocalSmsProvider", () => {
     });
 
     test("should throw SmsError when mkdir fails", async () => {
-      const mkdirError = new Error("Permission denied");
-      mockedFs.mkdir.mockRejectedValue(mkdirError);
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
+
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
-      const to = "+1234567890";
-      const message = "Test message";
+      memoryFs.mkdirError = new Error("Permission denied");
 
       await expect(
         provider.send({
-          to,
-          message,
+          to: "+1234567890",
+          message: "Test message",
         }),
       ).rejects.toThrow(SmsError);
+
       await expect(
         provider.send({
-          to,
-          message,
+          to: "+1234567890",
+          message: "Test 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 alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
+
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
-      const to = "+1234567890";
-      const message = "Test message";
+      memoryFs.writeFileError = new Error("Disk full");
 
       await expect(
         provider.send({
-          to,
-          message,
+          to: "+1234567890",
+          message: "Test message",
         }),
       ).rejects.toThrow(SmsError);
+
       await expect(
         provider.send({
-          to,
-          message,
+          to: "+1234567890",
+          message: "Test 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 alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
+
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
 
-      const to = "+1234567890";
-      const message = "Test message";
+      // Simulate non-Error throw
+      memoryFs.writeFileError = "String error" as unknown as Error;
 
       await expect(
         provider.send({
-          to,
-          message,
+          to: "+1234567890",
+          message: "Test message",
         }),
       ).rejects.toThrow(SmsError);
-      await expect(
-        provider.send({
-          to,
-          message,
-        }),
-      ).rejects.toThrow("Failed to save SMS to local file: String error");
+    });
+
+    test("should handle multiple recipients", async () => {
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
+
+      const provider = alepha.inject(LocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
+
+      await provider.send({
+        to: ["+1111111111", "+2222222222"],
+        message: "Broadcast message",
+      });
+
+      expect(memoryFs.writeFileCalls).toHaveLength(2);
+      expect(memoryFs.writeFileCalls[0].path).toContain("+1111111111");
+      expect(memoryFs.writeFileCalls[1].path).toContain("+2222222222");
+    });
+
+    test("should use custom directory when provided", async () => {
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
+
+      class CustomLocalSmsProvider extends LocalSmsProvider {
+        constructor() {
+          super({ directory: "custom-sms-dir" });
+        }
+      }
+
+      const provider = alepha.inject(CustomLocalSmsProvider);
+      const memoryFs = alepha.inject(MemoryFileSystemProvider);
+      await alepha.start();
+
+      await provider.send({
+        to: "+1234567890",
+        message: "Test",
+      });
+
+      expect(memoryFs.mkdirCalls[0].path).toBe("custom-sms-dir");
+      expect(memoryFs.joinCalls[0][0]).toBe("custom-sms-dir");
     });
   });
 
   describe("createSmsText", () => {
-    beforeEach(() => {
-      provider = new LocalSmsProvider();
+    let provider: LocalSmsProvider;
+
+    beforeEach(async () => {
+      const alepha = Alepha.create().with({
+        provide: FileSystemProvider,
+        use: MemoryFileSystemProvider,
+      });
+      provider = alepha.inject(LocalSmsProvider);
+      await alepha.start();
     });
 
     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,
+        to: "+1234567890",
+        message: "Test message",
       });
 
       expect(text).toContain("SMS Message");
@@ -210,12 +255,9 @@ describe("LocalSmsProvider", () => {
     });
 
     test("should handle multiline messages", () => {
-      const to = "+1234567890";
-      const message = "Line 1\nLine 2\nLine 3";
-
       const text = provider.createSmsText({
-        to,
-        message,
+        to: "+1234567890",
+        message: "Line 1\nLine 2\nLine 3",
       });
 
       expect(text).toContain("Line 1\nLine 2\nLine 3");

package/src/sms/providers/LocalSmsProvider.ts

@@ -1,5 +1,5 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
+import { $inject } from "alepha";
+import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
 import { SmsError } from "../errors/SmsError.ts";
 import type { SmsProvider, SmsSendOptions } from "./SmsProvider.ts";
@@ -7,17 +7,18 @@ import type { SmsProvider, SmsSendOptions } from "./SmsProvider.ts";
 export interface LocalSmsProviderOptions {
   /**
    * Directory to save SMS files.
-   * @default "node_modules/.sms" (relative to project root)
+   * @default "node_modules/.alepha/sms" (relative to project root)
    */
   directory?: string;
 }
 
 export class LocalSmsProvider implements SmsProvider {
   protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
   protected readonly directory: string;
 
   constructor(options: LocalSmsProviderOptions = {}) {
-    this.directory = options.directory ?? "node_modules/.sms";
+    this.directory = options.directory ?? "node_modules/.alepha/sms";
   }
 
   public async send(options: SmsSendOptions): Promise<void> {
@@ -31,14 +32,14 @@ export class LocalSmsProvider implements SmsProvider {
 
     try {
       // Ensure directory exists
-      await fs.mkdir(this.directory, { recursive: true });
+      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 filepath = path.join(this.directory, filename);
+        const filepath = this.fs.join(this.directory, filename);
 
         // Create text content
         const textContent = this.createSmsText({
@@ -47,7 +48,7 @@ export class LocalSmsProvider implements SmsProvider {
         });
 
         // Write to file
-        await fs.writeFile(filepath, textContent, "utf8");
+        await this.fs.writeFile(filepath, textContent);
 
         this.log.info("SMS saved to local file", { filepath, to });
       }

package/src/vite/helpers/boot.ts

@@ -1,4 +1,4 @@
-import { access, readFile } from "node:fs/promises";
+import { access, readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { AlephaError } from "alepha";
 
@@ -8,6 +8,17 @@ import { AlephaError } from "alepha";
  * For avoiding cli -> vite, all code moved here.
  */
 
+/**
+ * Server entry files in priority order.
+ * main.server.ts is preferred over main.ts for consistency.
+ */
+const SERVER_ENTRIES = [
+  "main.server.ts",
+  "main.server.tsx",
+  "main.ts",
+  "main.tsx",
+] as const;
+
 /**
  * Find browser/client entry file path.
  */
@@ -25,6 +36,8 @@ const getClientEntry = async (
 
 /**
  * Find server entry file path.
+ *
+ * Optimized to use a single readdir() call instead of multiple access() calls.
  */
 const getServerEntry = async (
   root = process.cwd(),
@@ -42,32 +55,30 @@ const getServerEntry = async (
     }
   }
 
-  const maybeEntry = [
-    "src/main.server.ts",
-    "src/server-entry.ts",
-    "src/main.server.tsx",
-    "src/server-entry.tsx",
-    "src/main.ts",
-    "src/main.tsx",
-  ];
+  // Single IO: read src/ directory listing
+  const srcDir = join(root, "src");
+  try {
+    const files = new Set(await readdir(srcDir));
 
-  for (const entry of maybeEntry) {
-    try {
-      const path = join(root, entry).replace(/\\/g, "/");
-      await access(path);
-      return path;
-    } catch {
-      // continue to next entry
+    // Find first matching entry in priority order
+    for (const entry of SERVER_ENTRIES) {
+      if (files.has(entry)) {
+        return join(srcDir, entry).replace(/\\/g, "/");
+      }
     }
+  } catch {
+    // src/ directory doesn't exist, fall through to client entry
   }
 
+  // Fallback: try client entry from index.html
   const clientEntry = await getClientEntry(root);
   if (clientEntry) {
     return clientEntry;
   }
 
+  const fullPaths = SERVER_ENTRIES.map((e) => `src/${e}`);
   throw new AlephaError(
-    `Could not find a server entry file. List of supported entry file: ${maybeEntry.join(", ")}`,
+    `Could not find a server entry file. Supported entries: ${fullPaths.join(", ")}`,
   );
 };
 

package/src/vite/helpers/importViteReact.ts

@@ -0,0 +1,13 @@
+import { createRequire } from "node:module";
+
+export const importViteReact = async (): Promise<any> => {
+  // Add React plugin for JSX/TSX compilation
+  try {
+    const { default: viteReact } = createRequire(import.meta.url)(
+      "@vitejs/plugin-react",
+    );
+    return viteReact;
+  } catch {
+    // @vitejs/plugin-react not installed, skip
+  }
+};

package/src/vite/index.ts

@@ -4,9 +4,8 @@ import type { Alepha } from "alepha";
 export * from "./helpers/boot.ts";
 export * from "./helpers/createBufferedLogger.ts";
 // Plugins (public API)
-export * from "./plugins/viteAlepha.ts";
-export * from "./plugins/viteAlephaBuild.ts";
 export * from "./plugins/viteAlephaDev.ts";
+export * from "./plugins/viteAlephaSsrPreload.ts";
 export * from "./plugins/viteCompress.ts";
 // Tasks (for CLI integration)
 export * from "./tasks/index.ts";
@@ -14,22 +13,3 @@ export * from "./tasks/index.ts";
 declare global {
   var __cli_alepha: Alepha;
 }
-
-/**
- * Plugin vite for Alepha framework.
- *
- * This module provides Vite plugins and configurations to integrate Alepha applications with Vite's build and development processes.
- *
- * @example
- * ```ts
- * import { defineConfig } from "vite";
- * import { viteAlepha } from "alepha/vite";
- *
- * export default defineConfig({
- *   plugins: [viteAlepha()],
- *   // other Vite configurations...
- * });
- * ```
- *
- * @module alepha.vite
- */

package/src/vite/plugins/viteAlephaDev.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { Plugin, ResolvedConfig } from "vite";
+import type { Plugin, ResolvedConfig, UserConfig } from "vite";
 import { boot } from "../helpers/boot.ts";
+import { importVite } from "../helpers/importVite.ts";
 import { createAlephaRunner, isViteInternalPath } from "../tasks/runAlepha.ts";
 
 export interface ViteAlephaDevOptions {
@@ -44,9 +45,20 @@ export async function viteAlephaDev(
     debug: options.debug,
   });
 
+  const { loadEnv } = await importVite();
+  const env = loadEnv("development", process.cwd(), "SERVER");
+
+  const config: UserConfig = {};
+  if (env.SERVER_PORT) {
+    config.server = {
+      port: parseInt(env.SERVER_PORT, 10),
+    };
+  }
+
   return {
     name: "alepha-dev",
     apply: "serve",
+    config: () => config,
     configResolved(resolvedConfig: ResolvedConfig) {
       runner.setConfig(resolvedConfig);
     },
@@ -103,6 +115,9 @@ export async function viteAlephaDev(
       }
     },
     async configureServer(server) {
+      if (env.SERVER_PORT) {
+        server.config.server.port = parseInt(env.SERVER_PORT, 10);
+      }
       const middleware = (
         req: IncomingMessage,
         res: ServerResponse,