alepha 0.14.4 → 0.15.1

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/index.ts

@@ -1,15 +1,16 @@
 import type { Alepha } from "alepha";
 
 // Helpers (for advanced use)
-export * from "./helpers/boot.ts";
 export * from "./helpers/createBufferedLogger.ts";
+export * from "./helpers/importVite.ts";
+export * from "./helpers/importViteReact.ts";
 // Plugins (public API)
-export * from "./plugins/viteAlephaDev.ts";
 export * from "./plugins/viteAlephaSsrPreload.ts";
 export * from "./plugins/viteCompress.ts";
 // Tasks (for CLI integration)
 export * from "./tasks/index.ts";
 
 declare global {
+  var __alepha: Alepha;
   var __cli_alepha: Alepha;
 }

package/src/vite/tasks/buildClient.ts

@@ -103,7 +103,6 @@ export async function buildClient(opts: BuildClientOptions): Promise<void> {
       outDir: opts.dist,
       // Generate manifest for SSR module preloading
       manifest: true,
-      ssrManifest: true,
       rollupOptions: {
         output: {
           entryFileNames: "entry.[hash].js",

package/src/vite/tasks/buildServer.ts

@@ -1,6 +1,6 @@
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { AlephaError } from "alepha";
+import { type Alepha, AlephaError } from "alepha";
 import type * as vite from "vite";
 import type { UserConfig } from "vite";
 import { analyzer as viteAnalyzer } from "vite-bundle-analyzer";
@@ -27,11 +27,6 @@ export interface BuildServerOptions {
    */
   clientDir?: string;
 
-  /**
-   * Override Vite config options.
-   */
-  config?: UserConfig;
-
   /**
    * If true, generate build stats report.
    */
@@ -43,6 +38,16 @@ export interface BuildServerOptions {
    * @default false
    */
   silent?: boolean;
+
+  /**
+   * Add more entry point conditions for SSR module resolution (e.g., "bun").
+   */
+  conditions?: string[];
+
+  /**
+   * Alepha instance to set SSR manifest for pre-rendering.
+   */
+  alepha: Alepha;
 }
 
 export interface BuildServerResult {
@@ -50,6 +55,15 @@ export interface BuildServerResult {
    * The filename of the built server entry (e.g., "abc123.js").
    */
   entryFile: string;
+
+  /**
+   * SSR manifest data for module preloading.
+   * Can be used to set in alepha store for pre-rendering.
+   */
+  manifest?: {
+    client?: Record<string, any>;
+    preload?: Record<string, string>;
+  };
 }
 
 /**
@@ -62,7 +76,7 @@ export interface BuildServerResult {
 export async function buildServer(
   opts: BuildServerOptions,
 ): Promise<BuildServerResult> {
-  const { build: viteBuild, mergeConfig } = await importVite();
+  const { build: viteBuild, resolveConfig } = await importVite();
   const plugins: any[] = [];
 
   const viteReact = await importViteReact();
@@ -83,6 +97,12 @@ export async function buildServer(
   // Create buffered logger for silent mode
   const logger = opts.silent ? createBufferedLogger() : undefined;
 
+  const conditions = ["node", "import", "module", "default"];
+  if (opts.conditions) {
+    conditions.unshift(...opts.conditions);
+  }
+
+  // note: we still can override this config via config file (vite.config.ts)
   const viteBuildServerConfig: UserConfig = {
     mode: "production",
     logLevel: opts.silent ? "silent" : undefined,
@@ -92,6 +112,7 @@ export async function buildServer(
     publicDir: false,
     ssr: {
       noExternal: true,
+      resolve: { conditions },
     },
     build: {
       sourcemap: true,
@@ -100,7 +121,7 @@ export async function buildServer(
       minify: true,
       chunkSizeWarningLimit: 10000,
       rollupOptions: {
-        external: ["bun"],
+        external: [/^bun(:|$)/, /^cloudflare:/],
         output: {
           entryFileNames: "[hash].js",
           chunkFileNames: "[hash].js",
@@ -110,24 +131,32 @@ export async function buildServer(
       },
     },
     esbuild: { legalComments: "none", keepNames: true },
-    customLogger: logger,
+    customLogger: logger, // mock logger to avoid noisy output
     plugins,
   };
 
+  // create inline config by merging alepha built-in + extended config
+
   let result: vite.Rollup.RollupOutput | vite.Rollup.RollupOutput[];
   try {
-    result = (await viteBuild(
-      mergeConfig(viteBuildServerConfig, opts.config || {}),
-    )) as vite.Rollup.RollupOutput | vite.Rollup.RollupOutput[];
+    result = (await viteBuild(viteBuildServerConfig)) as
+      | vite.Rollup.RollupOutput
+      | vite.Rollup.RollupOutput[];
   } catch (error) {
-    // Flush buffered logs on failure so user can see what happened
+    // flush buffered logs on failure so user can see what happened
     logger?.flush();
     throw error;
   }
 
-  // Extract resolved config to get externals
-  const resolvedConfig = (result as any).resolvedConfig;
-  const externals: string[] = resolvedConfig?.ssr?.external ?? [];
+  // resolve final config to read externals
+  const resolvedConfig = await resolveConfig(viteBuildServerConfig, "build");
+
+  // extract resolved config to get externals
+  const externals: string[] = [];
+
+  if (Array.isArray(resolvedConfig?.ssr?.external)) {
+    externals.push(...resolvedConfig.ssr.external);
+  }
 
   // Generate package.json with externals
   await generateExternals({
@@ -150,21 +179,29 @@ export async function buildServer(
   // Embed SSR manifests if client was built
   // This bundles all manifest data into index.js for serverless deployments
   let manifest = "";
+  let manifestData:
+    | { client?: Record<string, any>; preload?: Record<string, string> }
+    | undefined;
+
   if (opts.clientDir) {
     const viteDir = `${opts.distDir}/${opts.clientDir}/.vite`;
-    const ssrManifest = await loadJsonFile(`${viteDir}/ssr-manifest.json`);
     const clientManifest = await loadJsonFile(`${viteDir}/manifest.json`);
     const preloadManifest = await loadJsonFile(
       `${viteDir}/preload-manifest.json`,
     );
 
-    const combined = {
-      ssr: ssrManifest,
-      client: clientManifest,
+    // Strip unused fields from client manifest to reduce bundle size
+    const strippedClientManifest = stripClientManifest(clientManifest);
+
+    manifestData = {
+      client: strippedClientManifest,
       preload: preloadManifest,
     };
 
-    manifest = `__alepha.set("alepha.react.ssr.manifest", ${JSON.stringify(combined)});\n`;
+    manifest = `__alepha.set("alepha.react.ssr.manifest", ${JSON.stringify(manifestData)});\n`;
+
+    // Set manifest in alepha store for pre-rendering
+    opts.alepha.store.set("alepha.react.ssr.manifest" as any, manifestData);
 
     // Remove .vite directory - no longer needed at runtime
     await rm(viteDir, { recursive: true, force: true });
@@ -180,7 +217,7 @@ export async function buildServer(
     `${warning}\n${template}${manifest}import './server/${entryFile}';\n`.trim(),
   );
 
-  return { entryFile };
+  return { entryFile, manifest: manifestData };
 }
 
 /**
@@ -195,6 +232,27 @@ async function loadJsonFile(path: string): Promise<any> {
   }
 }
 
+/**
+ * Strip unused fields from client manifest to reduce bundle size.
+ * Only keeps: file, isEntry, imports, css
+ */
+function stripClientManifest(
+  manifest: Record<string, any> | undefined,
+): Record<string, any> | undefined {
+  if (!manifest) return undefined;
+
+  const stripped: Record<string, any> = {};
+  for (const [key, entry] of Object.entries(manifest)) {
+    stripped[key] = {
+      file: entry.file,
+      ...(entry.isEntry && { isEntry: entry.isEntry }),
+      ...(entry.imports?.length && { imports: entry.imports }),
+      ...(entry.css?.length && { css: entry.css }),
+    };
+  }
+  return stripped;
+}
+
 /**
  * Extract entry filename from Vite build result.
  */

package/src/vite/tasks/copyAssets.ts

@@ -1,9 +1,10 @@
 import { cp, mkdir } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
-import { importAlepha } from "../helpers/importAlepha.ts";
+import type { Alepha } from "alepha";
 
 export interface CopyAssetsOptions {
+  alepha: Alepha;
   /**
    * Entry point for the built Alepha application.
    */
@@ -17,7 +18,7 @@ export interface CopyAssetsOptions {
   /**
    * @default process.cwd()
    */
-  root?: string;
+  root: string;
 
   /**
    * Add Runner for logging (@see Alepha CLI)
@@ -38,8 +39,8 @@ export interface CopyAssetsOptions {
  * Used by modules like AlephaServerSwagger to distribute UI files.
  */
 export async function copyAssets(opts: CopyAssetsOptions): Promise<void> {
-  const root = opts.root ?? process.cwd();
-  const alepha = await importAlepha(opts.entry);
+  const root = opts.root;
+  const alepha = opts.alepha;
   const assets = alepha.store.get("alepha.build.assets");
 
   if (!assets || assets.length === 0) {