alepha 0.14.4 → 0.15.0

package/src/orm/providers/drivers/BunPostgresProvider.ts

@@ -1,7 +1,6 @@
 import { $env, $hook, $inject, AlephaError, type Static, t } from "alepha";
 import { $lock } from "alepha/lock";
 import { $logger } from "alepha/logger";
-import type { SQL as BunSQL } from "bun";
 import { sql } from "drizzle-orm";
 import type { BunSQLDatabase } from "drizzle-orm/bun-sql";
 import type { PgDatabase } from "drizzle-orm/pg-core";
@@ -55,13 +54,13 @@ export class BunPostgresProvider extends DatabaseProvider {
   protected readonly kit = $inject(DrizzleKitProvider);
   protected readonly builder = $inject(PostgresModelBuilder);
 
-  protected client?: BunSQL;
+  protected client?: Bun.SQL;
   protected bunDb?: BunSQLDatabase;
 
   public readonly dialect = "postgresql";
 
   public get name() {
-    return "bun-postgres";
+    return "postgres";
   }
 
   /**
@@ -184,10 +183,9 @@ export class BunPostgresProvider extends DatabaseProvider {
     }
 
     const { drizzle } = await import("drizzle-orm/bun-sql");
-    const { SQL } = await import("bun");
 
     // Create Bun SQL client
-    this.client = new SQL(this.url);
+    this.client = new Bun.SQL(this.url);
 
     // Test connection
     await this.client.unsafe("SELECT 1");

package/src/orm/providers/drivers/BunSqliteProvider.ts

@@ -84,7 +84,7 @@ export class BunSqliteProvider extends DatabaseProvider {
   protected bunDb?: BunSQLiteDatabase;
 
   public get name() {
-    return "bun-sqlite";
+    return "sqlite";
   }
 
   public override readonly dialect = "sqlite";

package/src/orm/providers/drivers/CloudflareD1Provider.ts

@@ -73,6 +73,10 @@ export class CloudflareD1Provider extends DatabaseProvider {
   protected drizzleDb?: DrizzleD1Database;
 
   public get name() {
+    return "sqlite";
+  }
+
+  public get driver() {
     return "d1";
   }
 

package/src/orm/providers/drivers/DatabaseProvider.ts

@@ -41,6 +41,10 @@ export abstract class DatabaseProvider {
     return "default";
   }
 
+  public get driver(): string {
+    return this.dialect;
+  }
+
   public get schema() {
     return "public";
   }

package/src/orm/providers/drivers/PglitePostgresProvider.ts

@@ -43,6 +43,10 @@ export class PglitePostgresProvider extends DatabaseProvider {
   protected pglite?: PgliteDatabase;
 
   public get name() {
+    return "postgres";
+  }
+
+  public get driver() {
     return "pglite";
   }
 

package/src/orm/services/Repository.ts

@@ -11,6 +11,7 @@ import {
   t,
 } from "alepha";
 import { type DateTime, DateTimeProvider } from "alepha/datetime";
+import { $logger } from "alepha/logger";
 import { asc, desc, isSQLWrapper, type SQL } from "drizzle-orm";
 import type {
   LockConfig,
@@ -62,6 +63,7 @@ export abstract class Repository<T extends TObject> {
   public readonly entity: EntityPrimitive<T>;
   public readonly provider: DatabaseProvider;
 
+  protected readonly log = $logger();
   protected readonly relationManager = $inject(PgRelationManager);
   protected readonly queryManager = $inject(QueryManager);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
@@ -200,6 +202,12 @@ export abstract class Repository<T extends TObject> {
     ) => Promise<T>,
     config?: PgTransactionConfig,
   ): Promise<T> {
+    if (this.provider.driver === "pglite") {
+      this.log.warn("Transactions are not supported with pglite driver");
+      return await transaction(null as any);
+    }
+
+    this.log.debug(`Starting transaction on table ${this.tableName}`);
     return await this.db.transaction(transaction, config);
   }
 

package/src/redis/index.bun.ts

@@ -0,0 +1,35 @@
+import { $module, type Alepha } from "alepha";
+import { BunRedisProvider } from "./providers/BunRedisProvider.ts";
+import { BunRedisSubscriberProvider } from "./providers/BunRedisSubscriberProvider.ts";
+import { RedisProvider } from "./providers/RedisProvider.ts";
+import { RedisSubscriberProvider } from "./providers/RedisSubscriberProvider.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export * from "./providers/BunRedisProvider.ts";
+export * from "./providers/BunRedisSubscriberProvider.ts";
+export * from "./providers/RedisProvider.ts";
+export * from "./providers/RedisSubscriberProvider.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export const AlephaRedis = $module({
+  name: "alepha.redis",
+  services: [
+    BunRedisProvider,
+    BunRedisSubscriberProvider,
+    RedisProvider,
+    RedisSubscriberProvider,
+  ],
+  register: (alepha: Alepha) => {
+    alepha
+      .with({
+        provide: RedisProvider,
+        use: BunRedisProvider,
+      })
+      .with({
+        provide: RedisSubscriberProvider,
+        use: BunRedisSubscriberProvider,
+      });
+  },
+});

package/src/redis/providers/BunRedisProvider.ts

@@ -8,18 +8,13 @@ import {
   t,
 } from "alepha";
 import { $logger } from "alepha/logger";
-import type { RedisClient as BunRedisClient } from "bun";
 import { RedisProvider, type RedisSetOptions } from "./RedisProvider.ts";
 
 const envSchema = t.object({
-  REDIS_URL: t.optional(t.text()),
-  REDIS_PORT: t.integer({
-    default: "6379",
+  REDIS_URL: t.text({
+    default: "redis://localhost:6379",
+    description: "Redis connection URL",
   }),
-  REDIS_HOST: t.text({
-    default: "localhost",
-  }),
-  REDIS_PASSWORD: t.optional(t.text()),
 });
 
 declare module "alepha" {
@@ -34,10 +29,8 @@ declare module "alepha" {
  *
  * @example
  * ```ts
- * // Set REDIS_URL environment variable
- * // REDIS_URL=redis://localhost:6379
- *
- * // Or configure via REDIS_HOST, REDIS_PORT, REDIS_PASSWORD
+ * // Set REDIS_URL environment variable (default: redis://localhost:6379)
+ * // REDIS_URL=redis://:password@myredis.example.com:6379
  *
  * // Or configure programmatically
  * alepha.with({
@@ -50,9 +43,9 @@ export class BunRedisProvider extends RedisProvider {
   protected readonly log = $logger();
   protected readonly alepha = $inject(Alepha);
   protected readonly env = $env(envSchema);
-  protected client?: BunRedisClient;
+  protected client?: Bun.RedisClient;
 
-  public get publisher(): BunRedisClient {
+  public get publisher(): Bun.RedisClient {
     if (!this.client?.connected) {
       throw new AlephaError("Redis client is not ready");
     }
@@ -79,7 +72,7 @@ export class BunRedisProvider extends RedisProvider {
    */
   public override async connect(): Promise<void> {
     // Check if we're running in Bun
-    if (typeof Bun === "undefined") {
+    if (!this.alepha.isBun()) {
       throw new AlephaError(
         "BunRedisProvider requires the Bun runtime. Use NodeRedisProvider for Node.js.",
       );
@@ -87,9 +80,7 @@ export class BunRedisProvider extends RedisProvider {
 
     this.log.debug("Connecting...");
 
-    const { RedisClient } = await import("bun");
-
-    this.client = new RedisClient(this.getUrl(), {
+    this.client = new Bun.RedisClient(this.getUrl(), {
       autoReconnect: true,
       enableAutoPipelining: true,
     });
@@ -124,14 +115,12 @@ export class BunRedisProvider extends RedisProvider {
   /**
    * Create a duplicate connection for pub/sub or other isolated operations.
    */
-  public async duplicate(): Promise<BunRedisClient> {
+  public async duplicate(): Promise<Bun.RedisClient> {
     if (typeof Bun === "undefined") {
       throw new AlephaError("BunRedisProvider requires the Bun runtime.");
     }
 
-    const { RedisClient } = await import("bun");
-
-    const client = new RedisClient(this.getUrl(), {
+    const client = new Bun.RedisClient(this.getUrl(), {
       autoReconnect: true,
       enableAutoPipelining: true,
     });
@@ -279,26 +268,6 @@ export class BunRedisProvider extends RedisProvider {
    * Get the Redis connection URL.
    */
   protected getUrl(): string {
-    // Prefer REDIS_URL if set
-    if (this.env.REDIS_URL) {
-      return this.env.REDIS_URL;
-    }
-
-    // Build URL from components
-    const url = new URL("redis://127.0.0.1:6379");
-
-    if (this.env.REDIS_PASSWORD) {
-      url.password = this.env.REDIS_PASSWORD;
-    }
-
-    if (this.env.REDIS_HOST) {
-      url.hostname = this.env.REDIS_HOST;
-    }
-
-    if (this.env.REDIS_PORT) {
-      url.port = String(this.env.REDIS_PORT);
-    }
-
-    return url.toString();
+    return this.env.REDIS_URL;
   }
 }

package/src/redis/providers/BunRedisSubscriberProvider.ts

@@ -1,6 +1,5 @@
 import { $hook, $inject, Alepha, AlephaError } from "alepha";
 import { $logger } from "alepha/logger";
-import type { RedisClient as BunRedisClient } from "bun";
 import { BunRedisProvider } from "./BunRedisProvider.ts";
 import {
   RedisSubscriberProvider,
@@ -25,9 +24,9 @@ export class BunRedisSubscriberProvider extends RedisSubscriberProvider {
   protected readonly log = $logger();
   protected readonly alepha = $inject(Alepha);
   protected readonly redisProvider = $inject(BunRedisProvider);
-  protected client?: BunRedisClient;
+  protected client?: Bun.RedisClient;
 
-  public get subscriber(): BunRedisClient {
+  public get subscriber(): Bun.RedisClient {
     if (!this.client?.connected) {
       throw new AlephaError("Redis subscriber client is not ready");
     }

package/src/redis/providers/NodeRedisProvider.ts

@@ -4,19 +4,23 @@ import {
   type RedisClientType,
   type SetOptions,
 } from "@redis/client";
-import { $env, $hook, $inject, Alepha, type Static, t } from "alepha";
+import {
+  $env,
+  $hook,
+  $inject,
+  Alepha,
+  AlephaError,
+  type Static,
+  t,
+} from "alepha";
 import { $logger } from "alepha/logger";
 import { RedisProvider, type RedisSetOptions } from "./RedisProvider.ts";
 
 const envSchema = t.object({
-  REDIS_URL: t.optional(t.text()),
-  REDIS_PORT: t.integer({
-    default: "6379",
-  }),
-  REDIS_HOST: t.text({
-    default: "localhost",
+  REDIS_URL: t.text({
+    default: "redis://localhost:6379",
+    description: "Redis connection URL",
   }),
-  REDIS_PASSWORD: t.optional(t.text()),
 });
 
 declare module "alepha" {
@@ -39,10 +43,8 @@ export type NodeRedisClientOptions = Parameters<typeof createClient>[0];
  *
  * @example
  * ```ts
- * // Set REDIS_URL environment variable
- * // REDIS_URL=redis://localhost:6379
- *
- * // Or configure via REDIS_HOST, REDIS_PORT, REDIS_PASSWORD
+ * // Set REDIS_URL environment variable (default: redis://localhost:6379)
+ * // REDIS_URL=redis://:password@myredis.example.com:6379
  *
  * // Or configure programmatically
  * alepha.with({
@@ -59,7 +61,7 @@ export class NodeRedisProvider extends RedisProvider {
 
   public get publisher(): NodeRedisClient {
     if (!this.client.isReady) {
-      throw new Error("Redis client is not ready");
+      throw new AlephaError("Redis client is not ready");
     }
 
     return this.client;
@@ -235,27 +237,7 @@ export class NodeRedisProvider extends RedisProvider {
    * Get the Redis connection URL.
    */
   protected getUrl(): string {
-    // Prefer REDIS_URL if set
-    if (this.env.REDIS_URL) {
-      return this.env.REDIS_URL;
-    }
-
-    // Build URL from components
-    const url = new URL("redis://127.0.0.1:6379");
-
-    if (this.env.REDIS_PASSWORD) {
-      url.password = this.env.REDIS_PASSWORD;
-    }
-
-    if (this.env.REDIS_HOST) {
-      url.hostname = this.env.REDIS_HOST;
-    }
-
-    if (this.env.REDIS_PORT) {
-      url.port = String(this.env.REDIS_PORT);
-    }
-
-    return url.toString();
+    return this.env.REDIS_URL;
   }
 
   /**

package/src/{server/security → security}/__tests__/BasicAuth.spec.ts

@@ -3,7 +3,7 @@ import { $action, AlephaServer } from "alepha/server";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
   $basicAuth,
-  AlephaServerSecurity,
+  AlephaSecurity,
   ServerBasicAuthProvider,
 } from "../index.ts";
 
@@ -58,7 +58,7 @@ describe("Basic Authentication", () => {
   beforeEach(async () => {
     alepha = Alepha.create()
       .with(AlephaServer)
-      .with(AlephaServerSecurity)
+      .with(AlephaSecurity)
       .with(TestApp);
 
     await alepha.start();
@@ -269,7 +269,7 @@ describe("Basic Authentication", () => {
 
       const edgeAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(EdgeCaseApp);
 
       await edgeAlepha.start();
@@ -301,7 +301,7 @@ describe("Basic Authentication", () => {
 
       const emptyAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(EmptyPasswordApp);
 
       await emptyAlepha.start();
@@ -333,7 +333,7 @@ describe("Basic Authentication", () => {
 
       const specialAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(SpecialCharsApp);
 
       await specialAlepha.start();
@@ -365,7 +365,7 @@ describe("Basic Authentication", () => {
 
       const unicodeAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(UnicodeApp);
 
       await unicodeAlepha.start();
@@ -397,7 +397,7 @@ describe("Basic Authentication", () => {
 
       const unicodeAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(UnicodeApp);
 
       await unicodeAlepha.start();
@@ -434,7 +434,7 @@ describe("Basic Authentication", () => {
 
       const longAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(LongCredsApp);
 
       await longAlepha.start();
@@ -466,7 +466,7 @@ describe("Basic Authentication", () => {
 
       const emptyUserAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(EmptyUsernameApp);
 
       await emptyUserAlepha.start();
@@ -549,7 +549,7 @@ describe("Basic Authentication", () => {
 
       const wsAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(WhitespaceApp);
 
       await wsAlepha.start();
@@ -582,7 +582,7 @@ describe("Basic Authentication", () => {
 
       const wsAlepha = Alepha.create()
         .with(AlephaServer)
-        .with(AlephaServerSecurity)
+        .with(AlephaSecurity)
         .with(WhitespaceApp);
 
       await wsAlepha.start();

package/src/{server/security → security}/__tests__/ServerSecurityProvider-realm.spec.ts

@@ -1,14 +1,19 @@
 import { randomUUID } from "node:crypto";
 import { Alepha } from "alepha";
-import { $realm } from "alepha/security";
-import { $action, $route, ForbiddenError, ServerProvider } from "alepha/server";
+import {
+  $action,
+  $route,
+  AlephaServer,
+  ForbiddenError,
+  ServerProvider,
+} from "alepha/server";
 import { describe, expect, it } from "vitest";
-import { AlephaServerSecurity } from "../index.ts";
+import { $issuer, AlephaSecurity } from "../index.ts";
 
 describe("ServerSecurityProvider - Realm Protection", () => {
   it("should allow access when user belongs to the required realm", async () => {
     class TestApp {
-      realmA = $realm({
+      realmA = $issuer({
         secret: "test-realm-a",
         roles: [
           {
@@ -18,7 +23,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
         ],
       });
 
-      realmB = $realm({
+      realmB = $issuer({
         secret: "test-realm-b",
         roles: [
           {
@@ -43,7 +48,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 
@@ -85,7 +90,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
 
   it("should deny access when user does not belong to the required realm", async () => {
     class TestApp {
-      realmA = $realm({
+      realmA = $issuer({
         secret: "test-realm-a",
         roles: [
           {
@@ -95,7 +100,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
         ],
       });
 
-      realmB = $realm({
+      realmB = $issuer({
         secret: "test-realm-b",
         roles: [
           {
@@ -120,7 +125,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 
@@ -172,7 +177,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
 
   it("should work with actions when user has no realm attribute", async () => {
     class TestApp {
-      realmA = $realm({
+      realmA = $issuer({
         secret: "test-realm-a",
         roles: [
           {
@@ -188,7 +193,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 
@@ -215,7 +220,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
 
   it("should combine realm and permission checks", async () => {
     class TestApp {
-      realmA = $realm({
+      realmA = $issuer({
         secret: "test-realm-a",
         roles: [
           {
@@ -229,7 +234,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
         ],
       });
 
-      realmB = $realm({
+      realmB = $issuer({
         secret: "test-realm-b",
       });
 
@@ -248,7 +253,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 
@@ -336,7 +341,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
 
   it("should work with fetch requests when realm is valid", async () => {
     class TestApp {
-      realmA = $realm({
+      realmA = $issuer({
         secret: "test-realm-a",
         roles: [
           {
@@ -352,7 +357,7 @@ describe("ServerSecurityProvider - Realm Protection", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 

package/src/{server/security/providers → security/__tests__}/ServerSecurityProvider.spec.ts

@@ -1,15 +1,15 @@
 import { randomUUID } from "node:crypto";
 import { Alepha } from "alepha";
-import { $realm } from "alepha/security";
 import {
   $action,
+  AlephaServer,
   ForbiddenError,
   HttpError,
   ServerProvider,
   UnauthorizedError,
 } from "alepha/server";
 import { describe, expect, it } from "vitest";
-import { AlephaServerSecurity } from "../index.ts";
+import { $issuer, AlephaSecurity } from "../index.ts";
 
 describe("ServerSecurityProvider", () => {
   it("should protect action from unauthorized users", async () => {
@@ -19,7 +19,7 @@ describe("ServerSecurityProvider", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 
@@ -62,7 +62,7 @@ describe("ServerSecurityProvider", () => {
         group: "read",
         handler: () => "USER",
       });
-      realm = $realm({
+      issuer = $issuer({
         secret: "test",
         roles: [
           {
@@ -77,7 +77,7 @@ describe("ServerSecurityProvider", () => {
       });
     }
 
-    const alepha = Alepha.create().with(AlephaServerSecurity);
+    const alepha = Alepha.create().with(AlephaServer).with(AlephaSecurity);
     const app = alepha.inject(TestApp);
     await alepha.start();
 

package/src/security/index.browser.ts

@@ -11,3 +11,8 @@ export * from "./schemas/userAccountInfoSchema.ts";
 export const AlephaSecurity = $module({
   name: "alepha.security",
 });
+
+/**
+ * @deprecated Use `AlephaSecurity` instead. Server security providers are automatically registered when `AlephaServer` is available.
+ */
+export const AlephaServerSecurity = AlephaSecurity;