npm - alepha - Versions diffs - 0.19.1 → 0.19.2 - Mend

alepha 0.19.1 → 0.19.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (530) hide show

package/src/email/core/{providers → __tests__}/LocalEmailProvider.spec.ts RENAMED Viewed

@@ -1,6 +1,6 @@
 import { Alepha } from "alepha";
 import { FileSystemProvider, MemoryFileSystemProvider } from "alepha/system";
-import { beforeEach, describe, expect, test, vi } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { EmailError } from "../errors/EmailError.ts";
 import {
   LocalEmailProvider,
@@ -13,7 +13,7 @@ const DEFAULT_DIRECTORY = localEmailOptions.options.default.directory;
 describe("LocalEmailProvider", () => {
   describe("send", () => {
-    test("should successfully send email to local file", async () => {
+    it("should successfully send email to local file", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -35,10 +35,15 @@ describe("LocalEmailProvider", () => {
       expect(memoryFs.writeFileCalls).toHaveLength(1);
       expect(memoryFs.writeFileCalls[0].path).toContain("test@example.com");
-      expect(memoryFs.writeFileCalls[0].data).toContain(subject);
+      const written = JSON.parse(memoryFs.writeFileCalls[0].data as string);
+      expect(written.to).toBe(to);
+      expect(written.subject).toBe(subject);
+      expect(written.body).toBe(body);
+      expect(written.sentAt).toBeDefined();
     });
-    test("should create proper filename with sanitized email and timestamp", async () => {
+    it("should create proper filename with sanitized email and timestamp", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -65,13 +70,13 @@ describe("LocalEmailProvider", () => {
       expect(memoryFs.joinCalls).toHaveLength(1);
       expect(memoryFs.joinCalls[0]).toEqual([
         DEFAULT_DIRECTORY,
-        "user_test@example.com+2023-01-01T12-00-00-000Z.html",
+        "user_test@example.com,2023-01-01T12-00-00-000Z.eml.json",
       ]);
       vi.useRealTimers();
     });
-    test("should sanitize special characters in email address", async () => {
+    it("should sanitize special characters in email address", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -93,11 +98,11 @@ describe("LocalEmailProvider", () => {
       expect(memoryFs.joinCalls).toHaveLength(1);
       expect(memoryFs.joinCalls[0][1]).toMatch(
-        /user_script_@example\.com\+.+\.html/,
+        /user_script_@example\.com,.+\.eml\.json/,
       );
     });
-    test("should create proper HTML content", async () => {
+    it("should create proper JSON content", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -107,6 +112,9 @@ describe("LocalEmailProvider", () => {
       const memoryFs = alepha.inject(MemoryFileSystemProvider);
       await alepha.start();
+      const mockDate = new Date("2023-01-01T12:00:00.000Z");
+      vi.setSystemTime(mockDate);
       const to = "test@example.com";
       const subject = "Test <Subject>";
       const body = "<p>Test body with <strong>HTML</strong></p>";
@@ -117,18 +125,17 @@ describe("LocalEmailProvider", () => {
         body,
       });
-      const htmlContent = memoryFs.writeFileCalls[0].data;
+      const content = JSON.parse(memoryFs.writeFileCalls[0].data as string);
+      expect(content.to).toBe(to);
+      expect(content.subject).toBe(subject);
+      expect(content.body).toBe(body);
+      expect(content.sentAt).toBe("2023-01-01T12:00:00.000Z");
-      expect(htmlContent).toContain("<!DOCTYPE html>");
-      expect(htmlContent).toContain("Test &lt;Subject&gt;"); // escaped subject
-      expect(htmlContent).toContain("test@example.com");
-      expect(htmlContent).toContain(
-        "<p>Test body with <strong>HTML</strong></p>",
-      ); // body not escaped
-      expect(htmlContent).toContain("Sent:");
+      vi.useRealTimers();
     });
-    test("should throw EmailError when writeFile fails", async () => {
+    it("should throw EmailError when writeFile fails", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -161,7 +168,7 @@ describe("LocalEmailProvider", () => {
       ).rejects.toThrow("Failed to save email 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,
@@ -194,7 +201,7 @@ describe("LocalEmailProvider", () => {
       ).rejects.toThrow("Failed to save email to local file: String error");
     });
-    test("should handle multiple recipients", async () => {
+    it("should handle multiple recipients", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
@@ -216,150 +223,32 @@ describe("LocalEmailProvider", () => {
     });
   });
-  describe("createEmailHtml", () => {
-    let provider: LocalEmailProvider;
-    beforeEach(async () => {
+  describe("createEmailJson", () => {
+    it("should return structured email data with sentAt timestamp", async () => {
       const alepha = Alepha.create().with({
         provide: FileSystemProvider,
         use: MemoryFileSystemProvider,
       });
-      provider = alepha.inject(LocalEmailProvider);
+      const provider = alepha.inject(LocalEmailProvider);
       await alepha.start();
-    });
-    test("should create proper HTML structure", () => {
       const mockDate = new Date("2023-01-01T12:00:00.000Z");
       vi.setSystemTime(mockDate);
-      const to = "test@example.com";
-      const subject = "Test Subject";
-      const body = "<p>Test body</p>";
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
-      });
-      expect(html).toContain("<!DOCTYPE html>");
-      expect(html).toContain('<html lang="en">');
-      expect(html).toContain("<head>");
-      expect(html).toContain("<body>");
-      expect(html).toContain("Test Subject");
-      expect(html).toContain("test@example.com");
-      expect(html).toContain("<p>Test body</p>");
-      expect(html).toContain("2023-01-01T12:00:00.000Z");
-      vi.useRealTimers();
-    });
-    test("should escape HTML in subject and email address", () => {
-      const to = "test<script>@example.com";
-      const subject = "Test <Subject> & More";
-      const body = "<p>Test body</p>";
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
+      const result = provider.createEmailJson({
+        to: "test@example.com",
+        subject: "Test Subject",
+        body: "<p>Test body</p>",
       });
-      expect(html).toContain("test&lt;script&gt;@example.com");
-      expect(html).toContain("Test &lt;Subject&gt; &amp; More");
-      expect(html).not.toContain("test<script>@example.com");
-      expect(html).not.toContain("Test <Subject> & More");
-    });
-    test("should not escape HTML in body content", () => {
-      const to = "test@example.com";
-      const subject = "Test Subject";
-      const body = "<p>Test body with <strong>HTML</strong> & entities</p>";
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
+      expect(result).toEqual({
+        to: "test@example.com",
+        subject: "Test Subject",
+        body: "<p>Test body</p>",
+        sentAt: "2023-01-01T12:00:00.000Z",
       });
-      expect(html).toContain(
-        "<p>Test body with <strong>HTML</strong> & entities</p>",
-      );
-    });
-    test("should include CSS styles", () => {
-      const to = "test@example.com";
-      const subject = "Test Subject";
-      const body = "<p>Test body</p>";
-      const html = provider.createEmailHtml({
-        to,
-        subject,
-        body,
-      });
-      expect(html).toContain("<style>");
-      expect(html).toContain("font-family: Arial, sans-serif");
-      expect(html).toContain(".email-header");
-      expect(html).toContain(".email-body");
-      expect(html).toContain(".meta");
-    });
-  });
-  describe("escapeHtml", () => {
-    let provider: LocalEmailProvider;
-    beforeEach(async () => {
-      const alepha = Alepha.create().with({
-        provide: FileSystemProvider,
-        use: MemoryFileSystemProvider,
-      });
-      provider = alepha.inject(LocalEmailProvider);
-      await alepha.start();
-    });
-    test("should escape ampersands", () => {
-      const result = provider.escapeHtml("Tom & Jerry");
-      expect(result).toBe("Tom &amp; Jerry");
-    });
-    test("should escape less than signs", () => {
-      const result = provider.escapeHtml("5 < 10");
-      expect(result).toBe("5 &lt; 10");
-    });
-    test("should escape greater than signs", () => {
-      const result = provider.escapeHtml("10 > 5");
-      expect(result).toBe("10 &gt; 5");
-    });
-    test("should escape double quotes", () => {
-      const result = provider.escapeHtml('Say "Hello"');
-      expect(result).toBe("Say &quot;Hello&quot;");
-    });
-    test("should escape single quotes", () => {
-      const result = provider.escapeHtml("Don't worry");
-      expect(result).toBe("Don&#39;t worry");
-    });
-    test("should escape multiple special characters", () => {
-      const result = provider.escapeHtml(
-        '<script>alert("Hello & goodbye")</script>',
-      );
-      expect(result).toBe(
-        "&lt;script&gt;alert(&quot;Hello &amp; goodbye&quot;)&lt;/script&gt;",
-      );
-    });
-    test("should handle empty string", () => {
-      const result = provider.escapeHtml("");
-      expect(result).toBe("");
-    });
-    test("should handle string with no special characters", () => {
-      const result = provider.escapeHtml("Hello World");
-      expect(result).toBe("Hello World");
+      vi.useRealTimers();
     });
   });
 });

package/src/email/core/providers/LocalEmailProvider.ts CHANGED Viewed

@@ -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 { FileSystemProvider } from "alepha/system";
 import { EmailError } from "../errors/EmailError.ts";
@@ -34,7 +34,7 @@ declare module "alepha" {
 export class LocalEmailProvider implements EmailProvider {
   protected readonly log = $logger();
   protected readonly fs = $inject(FileSystemProvider);
-  protected readonly options = $use(localEmailOptions);
+  protected readonly options = $state(localEmailOptions);
   protected get directory(): string {
     return this.options.directory;
@@ -69,22 +69,14 @@ export class LocalEmailProvider implements EmailProvider {
     });
     try {
-      // Create filename: emailcontact+date
       const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
       for (const recipient of Array.isArray(to) ? to : [to]) {
         const sanitizedEmail = recipient.replace(/[^a-zA-Z0-9@.-]/g, "_");
-        const filename = `${sanitizedEmail}+${timestamp}.html`;
+        const filename = `${sanitizedEmail},${timestamp}.eml.json`;
         const filepath = this.fs.join(this.directory, filename);
-        // Create HTML content
-        const htmlContent = this.createEmailHtml({
-          to: recipient,
-          subject,
-          body,
-        });
-        // Write to file
-        await this.fs.writeFile(filepath, htmlContent);
+        const content = this.createEmailJson({ to: recipient, subject, body });
+        await this.fs.writeFile(filepath, JSON.stringify(content, null, 2));
         this.log.info("Email saved to local file", { filepath, to, subject });
       }
@@ -95,46 +87,16 @@ export class LocalEmailProvider implements EmailProvider {
     }
   }
-  public createEmailHtml(options: {
+  public createEmailJson(options: {
     to: string;
     subject: string;
     body: string;
-  }): string {
-    const { to, subject, body } = options;
-    const timestamp = new Date().toISOString();
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${this.escapeHtml(subject)}</title>
-    <style>
-        body { font-family: Arial, sans-serif; margin: 20px; }
-        .email-header { background-color: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
-        .email-body { background-color: #ffffff; padding: 15px; border: 1px solid #ddd; border-radius: 5px; }
-        .meta { font-size: 12px; color: #666; margin-bottom: 10px; }
-    </style>
-</head>
-<body>
-    <div class="email-header">
-        <div class="meta">Sent: ${timestamp}</div>
-        <div class="meta">To: ${this.escapeHtml(to)}</div>
-        <h1>${this.escapeHtml(subject)}</h1>
-    </div>
-    <div class="email-body">
-        ${body}
-    </div>
-</body>
-</html>`;
-  }
-  public escapeHtml(text: string): string {
-    return text
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;")
-      .replace(/'/g, "&#39;");
+  }): { to: string; subject: string; body: string; sentAt: string } {
+    return {
+      to: options.to,
+      subject: options.subject,
+      body: options.body,
+      sentAt: new Date().toISOString(),
+    };
   }
 }

package/src/email/smtp/providers/NodemailerEmailProvider.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { $atom, $env, $hook, $use, type Static, t } from "alepha";
+import { $atom, $env, $hook, $state, type Static, t } from "alepha";
 import {
   EmailError,
   type EmailProvider,
@@ -127,7 +127,7 @@ declare module "alepha" {
 export class NodemailerEmailProvider implements EmailProvider {
   protected readonly env = $env(envSchema);
   protected readonly log = $logger();
-  protected readonly options = $use(nodemailerEmailOptions);
+  protected readonly options = $state(nodemailerEmailOptions);
   protected transporter: Transporter | null = null;
   protected get host(): string {

package/src/lock/core/{primitives → __tests__}/$lock.middleware.spec.ts RENAMED Viewed

@@ -2,7 +2,7 @@ import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
 import { LockAcquireError } from "../errors/LockAcquireError.ts";
 import { AlephaLock } from "../index.ts";
-import { $lock } from "./$lock.ts";
+import { $lock } from "../primitives/$lock.ts";
 describe("$lock middleware", () => {
   test("executes handler when lock is available", async ({ expect }) => {

package/src/lock/core/primitives/$lock.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import {
   $atom,
   $context,
   $inject,
-  $use,
+  $state,
   AlephaError,
   type AsyncFn,
   createMiddleware,
@@ -391,7 +391,7 @@ export class LockPrimitive<TFunc extends AsyncFn> extends Primitive<
 > {
   protected readonly log = $logger();
   protected readonly provider = $inject(LockProvider);
-  protected readonly settings = $use(lockOptions);
+  protected readonly settings = $state(lockOptions);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   /**

package/src/logger/index.ts CHANGED Viewed

@@ -57,14 +57,19 @@ export const AlephaLogger = $module({
     const env = alepha.parseEnv(envSchema);
     // Support DEBUG env var (debug package convention) as shorthand for LOG_LEVEL/LOG_FORMAT.
+    // DEBUG=1 → LOG_LEVEL=trace LOG_FORMAT=pretty
     // DEBUG=alepha:* → LOG_LEVEL=alepha.*:debug,info LOG_FORMAT=pretty
     let logLevel = env.LOG_LEVEL;
     let logFormat = env.LOG_FORMAT;
     if (env.DEBUG) {
-      const patterns = env.DEBUG.split(",")
-        .map((p) => p.trim().replaceAll(":", "."))
-        .filter(Boolean);
-      logLevel ??= `${patterns.map((p) => `${p}:debug`).join(",")},info`;
+      if (env.DEBUG === "1" || env.DEBUG === "true") {
+        logLevel ??= "trace";
+      } else {
+        const patterns = env.DEBUG.split(",")
+          .map((p) => p.trim().replaceAll(":", "."))
+          .filter(Boolean);
+        logLevel ??= `${patterns.map((p) => `${p}:debug`).join(",")},info`;
+      }
       logFormat ??= "pretty";
     }
@@ -146,6 +151,7 @@ const envSchema = t.object({
    * Enable debug logging for specific modules using the `debug` package convention.
    *
    * @example
+   * DEBUG=1 # Shorthand for LOG_LEVEL=trace LOG_FORMAT=pretty
    * DEBUG=alepha:* # Enable debug logging for all alepha modules
    * DEBUG=alepha:orm:* # Enable debug logging for alepha.orm modules
    * DEBUG=* # Enable debug logging for all modules

package/src/mcp/transports/SseMcpTransport.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { $atom, $inject, $use, t } from "alepha";
+import { $atom, $inject, $state, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { $route } from "alepha/server";
 import {
@@ -60,7 +60,7 @@ export const mcpSseOptions = $atom({
  */
 export class SseMcpTransport {
   protected readonly log = $logger();
-  protected readonly options = $use(mcpSseOptions);
+  protected readonly options = $state(mcpSseOptions);
   protected readonly mcpServer = $inject(McpServerProvider);
   /**

package/src/orm/__tests__/ModelBuilder-tests.ts CHANGED Viewed

@@ -422,3 +422,56 @@ export const testComplexRelationships = async (alepha: Alepha) => {
   await app.products.clear({ force: true });
   await app.categories.clear({ force: true });
 };
+// ---------------------------------------------------------------------------
+// Expression-based index: LOWER username uniqueness
+// ---------------------------------------------------------------------------
+const usersWithLowerIndex = $entity({
+  name: "users_lower",
+  schema: t.object({
+    id: db.primaryKey(),
+    realm: t.text(),
+    username: t.text(),
+  }),
+  indexes: [
+    {
+      expressions: (self) => [self.realm, sql`LOWER(${self.username})`],
+      unique: true,
+      name: "users_lower_realm_username_idx",
+    },
+  ],
+});
+export const testExpressionIndex = async (alepha: Alepha) => {
+  class App {
+    users = $repository(usersWithLowerIndex);
+  }
+  const app = alepha.inject(App);
+  await alepha.start();
+  // Insert first user
+  await app.users.create({ realm: "default", username: "JohnDoe" });
+  // Same username different case in same realm should fail (unique LOWER index)
+  try {
+    await app.users.create({ realm: "default", username: "johndoe" });
+    expect.fail("Should have thrown unique constraint error");
+  } catch (error) {
+    expect(error).toBeDefined();
+  }
+  // Same username different realm should succeed
+  await app.users.create({ realm: "other", username: "JohnDoe" });
+  // Different username same realm should succeed
+  await app.users.create({ realm: "default", username: "JaneDoe" });
+  // Verify all 3 records exist
+  const all = await app.users.findMany({});
+  expect(all.length).toBe(3);
+  // Clean up
+  await app.users.clear({ force: true });
+};

package/src/orm/__tests__/ModelBuilder.spec.ts CHANGED Viewed

@@ -9,6 +9,7 @@ import { PostgresModelBuilder } from "../postgres/services/PostgresModelBuilder.
 import {
   testComplexRelationships,
   testCustomConfig,
+  testExpressionIndex,
   testModelBuilderFeatures,
 } from "./ModelBuilder-tests.ts";
@@ -390,6 +391,51 @@ describe("ModelBuilder", () => {
       expect(table.eventId.config.name).toBe("event_id");
     });
+    it("should build table with expression-based index", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: db.primaryKey(),
+          realm: t.text(),
+          username: t.text(),
+        }),
+        indexes: [
+          {
+            expressions: (self) => [self.realm, sql`LOWER(${self.username})`],
+            unique: true,
+            name: "users_realm_username_lower_idx",
+          },
+        ],
+      });
+      builder.buildTable(entity, options);
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
+    it("should build table with expression-only index", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: db.primaryKey(),
+          email: t.email(),
+        }),
+        indexes: [
+          {
+            expressions: (self) => [sql`LOWER(${self.email})`],
+            unique: true,
+            name: "users_email_lower_idx",
+          },
+        ],
+      });
+      builder.buildTable(entity, options);
+      expect(options.tables.has("users")).toBe(true);
+    });
     it("should not recreate table if it already exists", () => {
       const entity = $entity({
         name: "users",
@@ -560,6 +606,30 @@ describe("ModelBuilder", () => {
       expect(table).toBeDefined();
     });
+    it("should build table with expression-based index", () => {
+      const entity = $entity({
+        name: "users",
+        schema: t.object({
+          id: db.primaryKey(),
+          realm: t.text(),
+          username: t.text(),
+        }),
+        indexes: [
+          {
+            expressions: (self) => [self.realm, sql`LOWER(${self.username})`],
+            unique: true,
+            name: "users_realm_username_lower_idx",
+          },
+        ],
+      });
+      builder.buildTable(entity, options);
+      expect(options.tables.has("users")).toBe(true);
+      const table = options.tables.get("users");
+      expect(table).toBeDefined();
+    });
     it("should throw error for sequences", () => {
       expect(() => {
         builder.buildSequence({ name: "test_seq", options: {} } as any, {
@@ -832,5 +902,15 @@ describe("ModelBuilder", () => {
     it("should handle complex nested relationships (postgres)", async () => {
       await testComplexRelationships(Alepha.create().with(AlephaOrmPostgres));
     });
+    it("should enforce LOWER expression unique index (sqlite)", async () => {
+      await testExpressionIndex(
+        Alepha.create({ env: { DATABASE_URL: "sqlite://:memory:" } }),
+      );
+    });
+    it("should enforce LOWER expression unique index (postgres)", async () => {
+      await testExpressionIndex(Alepha.create().with(AlephaOrmPostgres));
+    });
   });
 });