alepha 0.14.4 → 0.15.1

package/src/orm/index.ts

@@ -1,10 +1,10 @@
 import { $module, type Alepha, t } from "alepha";
 import { AlephaDateTime } from "alepha/datetime";
-import * as drizzle from "drizzle-orm";
 import { $entity } from "./primitives/$entity.ts";
-import { $repository } from "./primitives/$repository.ts";
 import { $sequence } from "./primitives/$sequence.ts";
 import { DrizzleKitProvider } from "./providers/DrizzleKitProvider.ts";
+import { BunPostgresProvider } from "./providers/drivers/BunPostgresProvider.ts";
+import { BunSqliteProvider } from "./providers/drivers/BunSqliteProvider.ts";
 import { CloudflareD1Provider } from "./providers/drivers/CloudflareD1Provider.ts";
 import { DatabaseProvider } from "./providers/drivers/DatabaseProvider.ts";
 import { NodePostgresProvider } from "./providers/drivers/NodePostgresProvider.ts";
@@ -88,48 +88,21 @@ declare module "alepha" {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export { drizzle };
-export {
-  type Page,
-  type PageQuery,
-  pageQuerySchema,
-  pageSchema,
-} from "alepha";
-export { sql } from "drizzle-orm";
-export * from "drizzle-orm/pg-core";
-export * from "./constants/PG_SYMBOLS.ts";
-export * from "./errors/DbConflictError.ts";
-export * from "./errors/DbEntityNotFoundError.ts";
-export * from "./errors/DbError.ts";
-export * from "./errors/DbMigrationError.ts";
-export * from "./errors/DbVersionMismatchError.ts";
-export * from "./helpers/parseQueryString.ts";
-export * from "./helpers/pgAttr.ts";
-export * from "./interfaces/FilterOperators.ts";
-export * from "./interfaces/PgQuery.ts";
-export * from "./interfaces/PgQueryWhere.ts";
-export * from "./primitives/$entity.ts";
-export * from "./primitives/$repository.ts";
-export * from "./primitives/$sequence.ts";
-export * from "./primitives/$transaction.ts";
-export * from "./providers/DatabaseTypeProvider.ts";
-export * from "./providers/DrizzleKitProvider.ts";
-export * from "./providers/drivers/CloudflareD1Provider.ts";
-export * from "./providers/drivers/DatabaseProvider.ts";
+export * from "./index.shared-server.ts";
+export * from "./providers/drivers/BunPostgresProvider.ts";
+export * from "./providers/drivers/BunSqliteProvider.ts";
 export * from "./providers/drivers/NodePostgresProvider.ts";
 export * from "./providers/drivers/NodeSqliteProvider.ts";
-export * from "./providers/RepositoryProvider.ts";
-export * from "./schemas/insertSchema.ts";
-export * from "./schemas/legacyIdSchema.ts";
-export * from "./schemas/updateSchema.ts";
-export * from "./services/Repository.ts";
-export * from "./types/schema.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
  * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
  *
+ * Automatically selects the appropriate provider based on runtime:
+ * - Bun: Uses `BunPostgresProvider` or `BunSqliteProvider`
+ * - Node.js: Uses `NodePostgresProvider` or `NodeSqliteProvider`
+ *
  * ```ts
  * import { t } from "alepha";
  * import { $entity, $repository, db } from "alepha/postgres";
@@ -168,6 +141,10 @@ export * from "./types/schema.ts";
  * @see {@link $sequence}
  * @see {@link $repository}
  * @see {@link $transaction}
+ * @see {@link NodePostgresProvider} - Node.js Postgres implementation
+ * @see {@link NodeSqliteProvider} - Node.js SQLite implementation
+ * @see {@link BunPostgresProvider} - Bun Postgres implementation
+ * @see {@link BunSqliteProvider} - Bun SQLite implementation
  * @module alepha.postgres
  */
 export const AlephaPostgres = $module({
@@ -177,8 +154,10 @@ export const AlephaPostgres = $module({
     AlephaDateTime,
     DatabaseProvider,
     NodePostgresProvider,
-    PglitePostgresProvider,
     NodeSqliteProvider,
+    BunPostgresProvider,
+    BunSqliteProvider,
+    PglitePostgresProvider,
     CloudflareD1Provider,
     SqliteModelBuilder,
     PostgresModelBuilder,
@@ -204,6 +183,7 @@ export const AlephaPostgres = $module({
     const isSqlite = url?.startsWith("sqlite:");
     const isMemory = url?.includes(":memory:");
     const isFile = !!url && !isPostgres && !isMemory;
+    const isBun = alepha.isBun();
 
     if (url?.startsWith("cloudflare-d1:")) {
       alepha.with({
@@ -227,7 +207,7 @@ export const AlephaPostgres = $module({
       alepha.with({
         optional: true,
         provide: DatabaseProvider,
-        use: NodePostgresProvider,
+        use: isBun ? BunPostgresProvider : NodePostgresProvider,
       });
       return;
     }
@@ -235,7 +215,7 @@ export const AlephaPostgres = $module({
     alepha.with({
       optional: true,
       provide: DatabaseProvider,
-      use: NodeSqliteProvider,
+      use: isBun ? BunSqliteProvider : NodeSqliteProvider,
     });
   },
 });

package/src/orm/providers/DrizzleKitProvider.ts

@@ -47,9 +47,7 @@ export class DrizzleKitProvider {
       await this.saveDevMigrations(provider, snapshot, entry);
     }
 
-    this.log.info(
-      `Db '${provider.name}' synchronization OK [${Date.now() - now}ms]`,
-    );
+    this.log.info(`Sync with '${provider.name}' OK [${Date.now() - now}ms]`);
   }
 
   /**
@@ -81,8 +79,8 @@ export class DrizzleKitProvider {
         };
       }
 
-      const prev = prevSnapshot ?? (await kit.generateDrizzleJson({}));
-      const curr = await kit.generateDrizzleJson(models);
+      const prev = prevSnapshot ?? kit.generateDrizzleJson({});
+      const curr = kit.generateDrizzleJson(models);
       return {
         models,
         statements: await kit.generateMigration(prev, curr),

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,11 +63,23 @@ 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);
   protected readonly alepha = $inject(Alepha);
 
+  static of<T extends TObject>(
+    entity: EntityPrimitive<T>,
+    provider = DatabaseProvider,
+  ): new () => Repository<T> {
+    return class InlineRepository extends Repository<T> {
+      constructor() {
+        super(entity, provider);
+      }
+    };
+  }
+
   constructor(entity: EntityPrimitive<T>, provider = DatabaseProvider) {
     this.entity = entity;
     this.provider = this.alepha.inject(provider);
@@ -200,6 +213,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();