alepha 0.13.8 → 0.14.1

package/src/orm/index.ts

@@ -5,12 +5,14 @@ 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";
 import { NodeSqliteProvider } from "./providers/drivers/NodeSqliteProvider.ts";
 import { PglitePostgresProvider } from "./providers/drivers/PglitePostgresProvider.ts";
 import { RepositoryProvider } from "./providers/RepositoryProvider.ts";
-import { PgJsonQueryManager } from "./services/PgJsonQueryManager.ts";
 import { PgRelationManager } from "./services/PgRelationManager.ts";
 import { PostgresModelBuilder } from "./services/PostgresModelBuilder.ts";
 import { QueryManager } from "./services/QueryManager.ts";
@@ -113,6 +115,9 @@ export * from "./primitives/$repository.ts";
 export * from "./primitives/$sequence.ts";
 export * from "./primitives/$transaction.ts";
 export * from "./providers/DrizzleKitProvider.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";
@@ -174,13 +179,15 @@ export const AlephaPostgres = $module({
     NodePostgresProvider,
     PglitePostgresProvider,
     NodeSqliteProvider,
+    BunPostgresProvider,
+    BunSqliteProvider,
+    CloudflareD1Provider,
     SqliteModelBuilder,
     PostgresModelBuilder,
     DrizzleKitProvider,
     RepositoryProvider,
     Repository,
     PgRelationManager,
-    PgJsonQueryManager,
     QueryManager,
   ],
   register: (alepha: Alepha) => {
@@ -200,6 +207,15 @@ export const AlephaPostgres = $module({
     const isMemory = url?.includes(":memory:");
     const isFile = !!url && !isPostgres && !isMemory;
 
+    if (url?.startsWith("cloudflare-d1:")) {
+      alepha.with({
+        optional: true,
+        provide: DatabaseProvider,
+        use: CloudflareD1Provider,
+      });
+      return;
+    }
+
     if (hasPGlite && (isMemory || isFile || !url) && !isSqlite) {
       alepha.with({
         optional: true,
@@ -213,7 +229,7 @@ export const AlephaPostgres = $module({
       alepha.with({
         optional: true,
         provide: DatabaseProvider,
-        use: NodePostgresProvider,
+        use: alepha.isBun() ? BunPostgresProvider : NodePostgresProvider,
       });
       return;
     }
@@ -221,7 +237,7 @@ export const AlephaPostgres = $module({
     alepha.with({
       optional: true,
       provide: DatabaseProvider,
-      use: NodeSqliteProvider,
+      use: alepha.isBun() ? BunSqliteProvider : NodeSqliteProvider,
     });
   },
 });

package/src/orm/interfaces/PgQueryWhere.ts

@@ -20,12 +20,7 @@ export type PgQueryWhereOrSQL<
 // ---------------------------------------------------------------------------------------------------------------------
 
 type PgQueryWhereOperators<T extends TObject> = {
-  [Key in keyof Static<T>]?:
-    | FilterOperators<Static<T>[Key]>
-    | Static<T>[Key]
-    | (Static<T>[Key] extends object
-        ? NestedJsonbQuery<Static<T>[Key]>
-        : never);
+  [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key];
 };
 
 type PgQueryWhereConditions<
@@ -115,23 +110,3 @@ type PgQueryWhereRelations<
         >;
       }
     : {};
-
-/**
- * Recursively allow nested queries for JSONB object/array types
- */
-type NestedJsonbQuery<T> = T extends object
-  ? T extends Array<infer U>
-    ? // For arrays, allow querying array element properties
-      U extends object
-      ? {
-          [K in keyof U]?: FilterOperators<U[K]> | U[K];
-        }
-      : FilterOperators<U> | U
-    : // For objects, allow nested queries
-      {
-        [K in keyof T]?:
-          | FilterOperators<T[K]>
-          | T[K]
-          | (T[K] extends object ? NestedJsonbQuery<T[K]> : never);
-      }
-  : FilterOperators<T> | T;

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

@@ -0,0 +1,225 @@
+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";
+import { DbError } from "../../errors/DbError.ts";
+import { DbMigrationError } from "../../errors/DbMigrationError.ts";
+import { PostgresModelBuilder } from "../../services/PostgresModelBuilder.ts";
+import { DrizzleKitProvider } from "../DrizzleKitProvider.ts";
+import { DatabaseProvider, type SQLLike } from "./DatabaseProvider.ts";
+
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+
+const envSchema = t.object({
+  /**
+   * Main configuration for database connection.
+   * Accept a string in the format of a Postgres connection URL.
+   * Example: postgres://user:password@localhost:5432/database
+   * or
+   * Example: postgres://user:password@localhost:5432/database?sslmode=require
+   */
+  DATABASE_URL: t.optional(t.text()),
+
+  /**
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   */
+  POSTGRES_SCHEMA: t.optional(t.text()),
+});
+
+/**
+ * Bun PostgreSQL provider using Drizzle ORM with Bun's native SQL client.
+ *
+ * This provider uses Bun's built-in SQL class for PostgreSQL connections,
+ * which provides excellent performance on the Bun runtime.
+ *
+ * @example
+ * ```ts
+ * // Set DATABASE_URL environment variable
+ * // DATABASE_URL=postgres://user:password@localhost:5432/database
+ *
+ * // Or configure programmatically
+ * alepha.with({
+ *   provide: DatabaseProvider,
+ *   use: BunPostgresProvider,
+ * });
+ * ```
+ */
+export class BunPostgresProvider extends DatabaseProvider {
+  protected readonly log = $logger();
+  protected readonly env = $env(envSchema);
+  protected readonly kit = $inject(DrizzleKitProvider);
+  protected readonly builder = $inject(PostgresModelBuilder);
+
+  protected client?: BunSQL;
+  protected bunDb?: BunSQLDatabase;
+
+  public readonly dialect = "postgresql";
+
+  public get name() {
+    return "bun-postgres";
+  }
+
+  /**
+   * In testing mode, the schema name will be generated and deleted after the test.
+   */
+  protected schemaForTesting = this.alepha.isTest()
+    ? this.env.POSTGRES_SCHEMA?.startsWith("test_")
+      ? this.env.POSTGRES_SCHEMA
+      : this.generateTestSchemaName()
+    : undefined;
+
+  public override get url() {
+    if (!this.env.DATABASE_URL) {
+      throw new AlephaError("DATABASE_URL is not defined in the environment");
+    }
+
+    return this.env.DATABASE_URL;
+  }
+
+  /**
+   * Execute a SQL statement.
+   */
+  public override execute(
+    statement: SQLLike,
+  ): Promise<Array<Record<string, unknown>>> {
+    try {
+      return this.db.execute(statement);
+    } catch (error) {
+      throw new DbError("Error executing statement", error);
+    }
+  }
+
+  /**
+   * Get Postgres schema used by this provider.
+   */
+  public override get schema(): string {
+    if (this.schemaForTesting) {
+      return this.schemaForTesting;
+    }
+
+    if (this.env.POSTGRES_SCHEMA) {
+      return this.env.POSTGRES_SCHEMA;
+    }
+
+    return "public";
+  }
+
+  /**
+   * Get the Drizzle Postgres database instance.
+   */
+  public override get db(): PgDatabase<any> {
+    if (!this.bunDb) {
+      throw new AlephaError("Database not initialized");
+    }
+
+    return this.bunDb as unknown as PgDatabase<any>;
+  }
+
+  protected override async executeMigrations(
+    migrationsFolder: string,
+  ): Promise<void> {
+    const { migrate } = await import("drizzle-orm/bun-sql/migrator");
+    await migrate(this.bunDb!, { migrationsFolder });
+  }
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  protected readonly onStart = $hook({
+    on: "start",
+    handler: async () => {
+      await this.connect();
+
+      // never migrate in serverless mode (vercel, netlify, ...)
+      if (!this.alepha.isServerless()) {
+        try {
+          await this.migrate.run();
+        } catch (error) {
+          throw new DbMigrationError(error);
+        }
+      }
+    },
+  });
+
+  protected readonly onStop = $hook({
+    on: "stop",
+    handler: async () => {
+      // cleanup test schema
+      if (
+        this.alepha.isTest() &&
+        this.schemaForTesting &&
+        this.schemaForTesting.startsWith("test_")
+      ) {
+        // Additional validation: schema name must only contain safe characters
+        if (!/^test_[a-z0-9_]+$/i.test(this.schemaForTesting)) {
+          throw new AlephaError(
+            `Invalid test schema name: ${this.schemaForTesting}. Must match pattern: test_[a-z0-9_]+`,
+          );
+        }
+
+        this.log.warn(`Deleting test schema '${this.schemaForTesting}' ...`);
+        await this.execute(
+          sql`DROP SCHEMA IF EXISTS ${sql.raw(this.schemaForTesting)} CASCADE`,
+        );
+        this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
+      }
+
+      // close the connection
+      await this.close();
+    },
+  });
+
+  public async connect(): Promise<void> {
+    this.log.debug("Connect ..");
+
+    // Check if we're running in Bun
+    if (typeof Bun === "undefined") {
+      throw new AlephaError(
+        "BunPostgresProvider requires the Bun runtime. Use NodePostgresProvider for Node.js.",
+      );
+    }
+
+    const { drizzle } = await import("drizzle-orm/bun-sql");
+    const { SQL } = await import("bun");
+
+    // Create Bun SQL client
+    this.client = new SQL(this.url);
+
+    // Test connection
+    await this.client.unsafe("SELECT 1");
+
+    this.bunDb = drizzle({
+      client: this.client,
+      logger: {
+        logQuery: (query: string, params: unknown[]) => {
+          this.log.trace(query, { params });
+        },
+      },
+    });
+
+    this.log.info("Connection OK");
+  }
+
+  public async close(): Promise<void> {
+    if (this.client) {
+      this.log.debug("Close...");
+
+      await this.client.close();
+
+      this.client = undefined;
+      this.bunDb = undefined;
+
+      this.log.info("Connection closed");
+    }
+  }
+
+  protected migrate = $lock({
+    handler: async () => {
+      await this.migrateDatabase();
+    },
+  });
+}

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

@@ -0,0 +1,180 @@
+import type { Database } from "bun:sqlite";
+import { mkdir } from "node:fs/promises";
+import {
+  $atom,
+  $env,
+  $hook,
+  $inject,
+  $use,
+  AlephaError,
+  type Static,
+  t,
+} from "alepha";
+import { $logger } from "alepha/logger";
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import { SqliteModelBuilder } from "../../services/SqliteModelBuilder.ts";
+import { DrizzleKitProvider } from "../DrizzleKitProvider.ts";
+import { DatabaseProvider, type SQLLike } from "./DatabaseProvider.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+const envSchema = t.object({
+  DATABASE_URL: t.optional(t.text()),
+});
+
+/**
+ * Configuration options for the Bun SQLite database provider.
+ */
+export const bunSqliteOptions = $atom({
+  name: "alepha.postgres.bun-sqlite.options",
+  schema: t.object({
+    path: t.optional(
+      t.string({
+        description:
+          "Filepath or :memory:. If empty, provider will use DATABASE_URL from env.",
+      }),
+    ),
+  }),
+  default: {},
+});
+
+export type BunSqliteProviderOptions = Static<typeof bunSqliteOptions.schema>;
+
+declare module "alepha" {
+  interface State {
+    [bunSqliteOptions.key]: BunSqliteProviderOptions;
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Bun SQLite provider using Drizzle ORM with Bun's native SQLite client.
+ *
+ * This provider uses Bun's built-in `bun:sqlite` for SQLite connections,
+ * which provides excellent performance on the Bun runtime.
+ *
+ * @example
+ * ```ts
+ * // Set DATABASE_URL environment variable
+ * // DATABASE_URL=sqlite://./my-database.db
+ *
+ * // Or configure programmatically
+ * alepha.with({
+ *   provide: DatabaseProvider,
+ *   use: BunSqliteProvider,
+ * });
+ *
+ * // Or use options atom
+ * alepha.store.mut(bunSqliteOptions, (old) => ({
+ *   ...old,
+ *   path: ":memory:",
+ * }));
+ * ```
+ */
+export class BunSqliteProvider extends DatabaseProvider {
+  protected readonly kit = $inject(DrizzleKitProvider);
+  protected readonly log = $logger();
+  protected readonly env = $env(envSchema);
+  protected readonly builder = $inject(SqliteModelBuilder);
+  protected readonly options = $use(bunSqliteOptions);
+
+  protected sqlite?: Database;
+  protected bunDb?: BunSQLiteDatabase;
+
+  public get name() {
+    return "bun-sqlite";
+  }
+
+  public override readonly dialect = "sqlite";
+
+  public override get url(): string {
+    const path = this.options.path ?? this.env.DATABASE_URL;
+    if (path) {
+      if (path.startsWith("postgres://")) {
+        throw new AlephaError(
+          "Postgres URL is not supported for SQLite provider.",
+        );
+      }
+      return path;
+    }
+
+    if (this.alepha.isTest() || this.alepha.isServerless()) {
+      return ":memory:";
+    } else {
+      return "node_modules/.alepha/bun-sqlite.db";
+    }
+  }
+
+  public override get db(): PgDatabase<any> {
+    if (!this.bunDb) {
+      throw new AlephaError("Database not initialized");
+    }
+
+    return this.bunDb as unknown as PgDatabase<any>;
+  }
+
+  public override async execute(
+    query: SQLLike,
+  ): Promise<Array<Record<string, unknown>>> {
+    return (this.bunDb as BunSQLiteDatabase).all(query);
+  }
+
+  protected readonly onStart = $hook({
+    on: "start",
+    handler: async () => {
+      // Check if we're running in Bun
+      if (typeof Bun === "undefined") {
+        throw new AlephaError(
+          "BunSqliteProvider requires the Bun runtime. Use NodeSqliteProvider for Node.js.",
+        );
+      }
+
+      const { Database } = await import("bun:sqlite");
+      const { drizzle } = await import("drizzle-orm/bun-sqlite");
+
+      const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
+
+      if (filepath !== ":memory:" && filepath !== "") {
+        const dirname = filepath.split("/").slice(0, -1).join("/");
+        if (dirname) {
+          await mkdir(dirname, { recursive: true }).catch(() => null);
+        }
+      }
+
+      this.sqlite = new Database(filepath);
+
+      this.bunDb = drizzle({
+        client: this.sqlite,
+        logger: {
+          logQuery: (query: string, params: unknown[]) => {
+            this.log.trace(query, { params });
+          },
+        },
+      });
+
+      await this.migrateDatabase();
+
+      this.log.info(`Using Bun SQLite database at ${filepath}`);
+    },
+  });
+
+  protected readonly onStop = $hook({
+    on: "stop",
+    handler: async () => {
+      if (this.sqlite) {
+        this.log.debug("Closing Bun SQLite connection...");
+        this.sqlite.close();
+        this.sqlite = undefined;
+        this.bunDb = undefined;
+        this.log.info("Bun SQLite connection closed");
+      }
+    },
+  });
+
+  protected async executeMigrations(migrationsFolder: string): Promise<void> {
+    const { migrate } = await import("drizzle-orm/bun-sqlite/migrator");
+    await migrate(this.bunDb!, { migrationsFolder });
+  }
+}

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

@@ -0,0 +1,164 @@
+import { $env, $hook, $inject, AlephaError, t } from "alepha";
+import { $logger } from "alepha/logger";
+import type { DrizzleD1Database } from "drizzle-orm/d1";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import { SqliteModelBuilder } from "../../services/SqliteModelBuilder.ts";
+import { DrizzleKitProvider } from "../DrizzleKitProvider.ts";
+import { DatabaseProvider, type SQLLike } from "./DatabaseProvider.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * D1Database interface matching Cloudflare's D1 API.
+ */
+export interface D1Database {
+  prepare(query: string): D1PreparedStatement;
+  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<T[]>;
+  exec(query: string): Promise<D1ExecResult>;
+  dump(): Promise<ArrayBuffer>;
+}
+
+export interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement;
+  first<T = unknown>(colName?: string): Promise<T | null>;
+  run(): Promise<D1Result>;
+  all<T = unknown>(): Promise<D1Result<T>>;
+  raw<T = unknown>(): Promise<T[]>;
+}
+
+export interface D1Result<T = unknown> {
+  results: T[];
+  success: boolean;
+  meta: {
+    duration: number;
+    changes: number;
+    last_row_id: number;
+    served_by: string;
+    internal_stats: unknown;
+  };
+}
+
+export interface D1ExecResult {
+  count: number;
+  duration: number;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Cloudflare D1 SQLite provider using Drizzle ORM.
+ *
+ * This provider requires a D1 binding to be set via `cloudflareD1Options` before starting.
+ * The binding is typically obtained from the Cloudflare Workers environment.
+ *
+ * @example
+ * ```ts
+ * // In your Cloudflare Worker
+ * alepha.set(cloudflareD1Options, { binding: env.DB });
+ * ```
+ */
+export class CloudflareD1Provider extends DatabaseProvider {
+  protected readonly kit = $inject(DrizzleKitProvider);
+  protected readonly log = $logger();
+  protected readonly builder = $inject(SqliteModelBuilder);
+  protected readonly env = $env(
+    t.object({
+      DATABASE_URL: t.string({
+        description: "Expect to be 'cloudflare-d1://name:id'",
+      }),
+    }),
+  );
+
+  protected d1?: D1Database;
+  protected drizzleDb?: DrizzleD1Database;
+
+  public get name() {
+    return "d1";
+  }
+
+  public override readonly dialect = "sqlite";
+
+  public override get url(): string {
+    return this.env.DATABASE_URL;
+  }
+
+  public override get db(): PgDatabase<any> {
+    if (!this.drizzleDb) {
+      throw new AlephaError("D1 database not initialized");
+    }
+
+    return this.drizzleDb as unknown as PgDatabase<any>;
+  }
+
+  public override async execute(
+    query: SQLLike,
+  ): Promise<Array<Record<string, unknown>>> {
+    const { rows } = await (this.db as any).run(query);
+    return rows;
+  }
+
+  protected readonly onStart = $hook({
+    on: "start",
+    handler: async () => {
+      const [bindingName] = this.env.DATABASE_URL.replace(
+        "cloudflare-d1://",
+        "",
+      ).split(":");
+      const cloudflareEnv = this.alepha.store.get("cloudflare.env" as any);
+      if (!cloudflareEnv) {
+        throw new AlephaError(
+          "Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.",
+        );
+      }
+
+      const binding = cloudflareEnv[bindingName] as D1Database;
+      if (!binding) {
+        throw new AlephaError(
+          `D1 binding '${bindingName}' not found in Cloudflare Workers environment.`,
+        );
+      }
+
+      this.d1 = binding;
+
+      // Dynamic import to avoid crashes when not on Cloudflare
+      const { drizzle } = await import("drizzle-orm/d1");
+
+      this.drizzleDb = drizzle(this.d1) as DrizzleD1Database;
+
+      await this.migrateDatabase();
+
+      this.log.info("Using Cloudflare D1 database");
+    },
+  });
+
+  protected async executeMigrations(migrationsFolder: string): Promise<void> {
+    // Dynamic import for D1 migrator
+    const { migrate } = await import("drizzle-orm/d1/migrator");
+    await migrate(this.db as any, { migrationsFolder });
+  }
+
+  /**
+   * Override development migration to skip sync (not supported on D1).
+   * D1 requires proper migrations to be applied.
+   */
+  protected override async runDevelopmentMigration(
+    migrationsFolder: string,
+  ): Promise<void> {
+    await this.executeMigrations(migrationsFolder);
+  }
+
+  /**
+   * Override test migration to run migrations instead of sync.
+   * D1 doesn't support schema synchronization.
+   */
+  protected override async runTestMigration(): Promise<void> {
+    const migrationsFolder = this.getMigrationsFolder();
+    try {
+      await this.executeMigrations(migrationsFolder);
+    } catch {
+      this.log.warn(
+        "D1 migrations failed in test environment - ensure migrations exist",
+      );
+    }
+  }
+}