alepha 0.14.3 → 0.15.0

package/src/orm/index.ts

@@ -1,8 +1,6 @@
 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";
@@ -90,50 +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 "./index.shared-server.ts";
 export * from "./providers/drivers/BunPostgresProvider.ts";
 export * from "./providers/drivers/BunSqliteProvider.ts";
-export * from "./providers/drivers/CloudflareD1Provider.ts";
-export * from "./providers/drivers/DatabaseProvider.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";
@@ -172,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({
@@ -181,10 +154,10 @@ export const AlephaPostgres = $module({
     AlephaDateTime,
     DatabaseProvider,
     NodePostgresProvider,
-    PglitePostgresProvider,
     NodeSqliteProvider,
     BunPostgresProvider,
     BunSqliteProvider,
+    PglitePostgresProvider,
     CloudflareD1Provider,
     SqliteModelBuilder,
     PostgresModelBuilder,
@@ -210,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({
@@ -233,7 +207,7 @@ export const AlephaPostgres = $module({
       alepha.with({
         optional: true,
         provide: DatabaseProvider,
-        use: alepha.isBun() ? BunPostgresProvider : NodePostgresProvider,
+        use: isBun ? BunPostgresProvider : NodePostgresProvider,
       });
       return;
     }
@@ -241,7 +215,7 @@ export const AlephaPostgres = $module({
     alepha.with({
       optional: true,
       provide: DatabaseProvider,
-      use: alepha.isBun() ? BunSqliteProvider : NodeSqliteProvider,
+      use: isBun ? BunSqliteProvider : NodeSqliteProvider,
     });
   },
 });

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/queue/core/providers/WorkerProvider.spec.ts

@@ -1,4 +1,5 @@
 import { Alepha, t } from "alepha";
+import { $logger } from "alepha/logger";
 import { describe, expect, test, vi } from "vitest";
 import {
   $consumer,
@@ -13,6 +14,16 @@ const payloadSchema = t.object({
   count: t.integer(),
 });
 
+class TestWorkerProvider extends WorkerProvider {
+  public readonly log = $logger();
+  public workersRunning = 0;
+  public workerIntervals: Record<number, number> = {};
+  public abortController = new AbortController();
+  public waitForNextMessage(n: number): Promise<void> {
+    return super.waitForNextMessage(n);
+  }
+}
+
 describe("WorkerProvider", () => {
   const createTestApp = async (
     options: {
@@ -29,6 +40,11 @@ describe("WorkerProvider", () => {
       },
     });
 
+    app.with({
+      provide: WorkerProvider,
+      use: TestWorkerProvider,
+    });
+
     app.with({
       provide: QueueProvider,
       use: MemoryQueueProvider,
@@ -52,16 +68,16 @@ describe("WorkerProvider", () => {
       const app = await createTestApp();
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
-      const logSpy = vi.spyOn(workerProvider["log"], "debug");
+      const workerProvider = app.inject(TestWorkerProvider);
+      const logSpy = vi.spyOn(workerProvider.log, "debug");
 
       await app.start();
 
       expect(logSpy).toHaveBeenCalledWith("Starting worker n-0");
-      expect(workerProvider["workersRunning"]).toBe(1);
+      expect(workerProvider.workersRunning).toBe(1);
 
       await app.stop();
-      expect(workerProvider["workersRunning"]).toBe(0);
+      expect(workerProvider.workersRunning).toBe(0);
     });
 
     test("should start multiple workers with concurrency", async () => {
@@ -76,32 +92,32 @@ describe("WorkerProvider", () => {
       const app = await createTestApp({ workerConcurrency: 3 });
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
-      const logSpy = vi.spyOn(workerProvider["log"], "debug");
+      const workerProvider = app.inject(TestWorkerProvider);
+      const logSpy = vi.spyOn(workerProvider.log, "debug");
 
       await app.start();
 
       expect(logSpy).toHaveBeenCalledWith("Starting worker n-0");
       expect(logSpy).toHaveBeenCalledWith("Starting worker n-1");
       expect(logSpy).toHaveBeenCalledWith("Starting worker n-2");
-      expect(workerProvider["workersRunning"]).toBe(3);
+      expect(workerProvider.workersRunning).toBe(3);
 
       await app.stop();
-      expect(workerProvider["workersRunning"]).toBe(0);
+      expect(workerProvider.workersRunning).toBe(0);
     });
 
     test("should not start workers when no consumers", async () => {
       const app = await createTestApp();
 
-      const workerProvider = app.inject(WorkerProvider);
-      const logSpy = vi.spyOn(workerProvider["log"], "debug");
+      const workerProvider = app.inject(TestWorkerProvider);
+      const logSpy = vi.spyOn(workerProvider.log, "debug");
 
       await app.start();
 
       expect(logSpy).not.toHaveBeenCalledWith(
         expect.stringMatching(/Starting worker/),
       );
-      expect(workerProvider["workersRunning"]).toBe(0);
+      expect(workerProvider.workersRunning).toBe(0);
 
       await app.stop();
     });
@@ -120,20 +136,20 @@ describe("WorkerProvider", () => {
       const app = await createTestApp({ workerConcurrency: 2 });
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
-      const debugSpy = vi.spyOn(workerProvider["log"], "debug");
+      const workerProvider = app.inject(TestWorkerProvider);
+      const debugSpy = vi.spyOn(workerProvider.log, "debug");
 
       await app.start();
-      expect(workerProvider["workersRunning"]).toBe(2);
+      expect(workerProvider.workersRunning).toBe(2);
 
       // Simulate worker crash by manually decrementing counter
-      workerProvider["workersRunning"] = 1;
+      workerProvider.workersRunning = 1;
 
       // Call wakeUp - should detect missing worker and restart it
       workerProvider.wakeUp();
 
       expect(debugSpy).toHaveBeenCalledWith("Waking up workers...");
-      expect(workerProvider["workersRunning"]).toBe(2);
+      expect(workerProvider.workersRunning).toBe(2);
 
       await app.stop();
     });
@@ -150,16 +166,16 @@ describe("WorkerProvider", () => {
       const app = await createTestApp();
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
+      const workerProvider = app.inject(TestWorkerProvider);
 
       await app.start();
 
-      const oldController = workerProvider["abortController"];
+      const oldController = workerProvider.abortController;
       expect(oldController.signal.aborted).toBe(false);
 
       workerProvider.wakeUp();
 
-      const newController = workerProvider["abortController"];
+      const newController = workerProvider.abortController;
       expect(oldController.signal.aborted).toBe(true);
       expect(newController.signal.aborted).toBe(false);
       expect(newController).not.toBe(oldController);
@@ -217,8 +233,8 @@ describe("WorkerProvider", () => {
       const app = await createTestApp();
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
-      const errorSpy = vi.spyOn(workerProvider["log"], "error");
+      const workerProvider = app.inject(TestWorkerProvider);
+      const errorSpy = vi.spyOn(workerProvider.log, "error");
 
       await app.start();
 
@@ -230,7 +246,7 @@ describe("WorkerProvider", () => {
         .toBeTruthy();
 
       // Worker should still be running after processing error
-      expect(workerProvider["workersRunning"]).toBe(1);
+      expect(workerProvider.workersRunning).toBe(1);
 
       await app.stop();
     });
@@ -282,9 +298,9 @@ describe("WorkerProvider", () => {
       const app = await createTestApp();
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
+      const workerProvider = app.inject(TestWorkerProvider);
       const queueProvider = app.inject(QueueProvider);
-      const errorSpy = vi.spyOn(workerProvider["log"], "error");
+      const errorSpy = vi.spyOn(workerProvider.log, "error");
 
       await app.start();
 
@@ -301,7 +317,7 @@ describe("WorkerProvider", () => {
       );
 
       // Worker should still be running
-      expect(workerProvider["workersRunning"]).toBe(1);
+      expect(workerProvider.workersRunning).toBe(1);
 
       await app.stop();
     });
@@ -318,9 +334,9 @@ describe("WorkerProvider", () => {
       const app = await createTestApp();
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
+      const workerProvider = app.inject(TestWorkerProvider);
       const queueProvider = app.inject(QueueProvider);
-      const errorSpy = vi.spyOn(workerProvider["log"], "error");
+      const errorSpy = vi.spyOn(workerProvider.log, "error");
 
       await app.start();
 
@@ -342,7 +358,7 @@ describe("WorkerProvider", () => {
       );
 
       // Worker should still be running
-      expect(workerProvider["workersRunning"]).toBe(1);
+      expect(workerProvider.workersRunning).toBe(1);
 
       await app.stop();
     });
@@ -359,16 +375,16 @@ describe("WorkerProvider", () => {
       const app = await createTestApp({ workerInterval: 5000 });
       app.with(TestService);
 
-      const workerProvider = app.inject(WorkerProvider);
-      const warnSpy = vi.spyOn(workerProvider["log"], "warn");
+      const workerProvider = app.inject(TestWorkerProvider);
+      const warnSpy = vi.spyOn(workerProvider.log, "warn");
 
       await app.start();
 
       // Abort the controller to simulate abort during wait
-      workerProvider["abortController"].abort();
+      workerProvider.abortController.abort();
 
       // This should detect the abort and return early
-      await workerProvider["waitForNextMessage"](0);
+      await workerProvider.waitForNextMessage(0);
 
       expect(warnSpy).toHaveBeenCalledWith("Worker n-0 aborted.");
 

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");
     }