alepha 0.14.0 → 0.14.2

package/src/orm/index.ts

@@ -5,13 +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,12 +114,14 @@ 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/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/PostgresTypeProvider.ts";
 export * from "./providers/RepositoryProvider.ts";
 export * from "./schemas/insertSchema.ts";
 export * from "./schemas/legacyIdSchema.ts";
@@ -132,21 +135,25 @@ export * from "./types/schema.ts";
  * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
  *
  * ```ts
+ * import { t } from "alepha";
+ * import { $entity, $repository, db } from "alepha/postgres";
+ *
  * const users = $entity({
  *   name: "users",
  *   schema: t.object({
- *     id: pg.primaryKey(),
+ *     id: db.primaryKey(),
  *     name: t.text(),
  *     email: t.text(),
  *   }),
  * });
  *
- * class Db {
+ * class App {
  *   users = $repository(users);
- * }
  *
- * const db = alepha.inject(Db);
- * const user = await db.users.one({ name: { eq: "John Doe" } });
+ *   getUserByName(name: string) {
+ *     return this.users.findOne({ name: { eq: name } });
+ *   }
+ * }
  * ```
  *
  * This is not a full ORM, but rather a set of tools to work with Postgres databases in a type-safe way.
@@ -176,6 +183,8 @@ export const AlephaPostgres = $module({
     NodePostgresProvider,
     PglitePostgresProvider,
     NodeSqliteProvider,
+    BunPostgresProvider,
+    BunSqliteProvider,
     CloudflareD1Provider,
     SqliteModelBuilder,
     PostgresModelBuilder,
@@ -183,7 +192,6 @@ export const AlephaPostgres = $module({
     RepositoryProvider,
     Repository,
     PgRelationManager,
-    PgJsonQueryManager,
     QueryManager,
   ],
   register: (alepha: Alepha) => {
@@ -225,7 +233,7 @@ export const AlephaPostgres = $module({
       alepha.with({
         optional: true,
         provide: DatabaseProvider,
-        use: NodePostgresProvider,
+        use: alepha.isBun() ? BunPostgresProvider : NodePostgresProvider,
       });
       return;
     }
@@ -233,7 +241,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/{PostgresTypeProvider.ts → DatabaseTypeProvider.ts}

@@ -35,7 +35,7 @@ import {
 import type { PgAttr } from "../helpers/pgAttr.ts";
 import { pgAttr } from "../helpers/pgAttr.ts";
 
-export class PostgresTypeProvider {
+export class DatabaseTypeProvider {
   public readonly attr = pgAttr;
 
   /**
@@ -239,7 +239,7 @@ export class PostgresTypeProvider {
 
   /**
    * Creates a page schema for a given object schema.
-   * It's used by {@link RepositoryPrimitive#paginate} method.
+   * It's used by {@link Repository#paginate} method.
    */
   public readonly page = <T extends TObject>(
     resource: T,
@@ -249,4 +249,26 @@ export class PostgresTypeProvider {
   };
 }
 
-export const pg = new PostgresTypeProvider();
+/**
+ * Wrapper of TypeProvider (`t`) for database types.
+ *
+ * Use `db` for improve TypeBox schema definitions with database-specific attributes.
+ *
+ * @example
+ * ```ts
+ * import { t } from "alepha";
+ * import { db } from "alepha/orm";
+ *
+ * const userSchema = t.object({
+ *   id: db.primaryKey(t.uuid()),
+ *   email: t.email(),
+ *   createdAt: db.createdAt(),
+ * });
+ * ```
+ */
+export const db = new DatabaseTypeProvider();
+
+/**
+ * @deprecated Use `db` instead.
+ */
+export const pg = db;

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/DatabaseProvider.ts

@@ -176,4 +176,29 @@ export abstract class DatabaseProvider {
    * MUST be implemented by each provider
    */
   protected abstract executeMigrations(migrationsFolder: string): Promise<void>;
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  /**
+   * For testing purposes, generate a unique schema name.
+   * The schema name will be generated based on the current date and time.
+   * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
+   */
+  protected generateTestSchemaName(): string {
+    const pad = (n: number) => n.toString().padStart(2, "0");
+
+    const now = new Date();
+    const year = now.getUTCFullYear();
+    const month = pad(now.getUTCMonth() + 1);
+    const day = pad(now.getUTCDate());
+    const hours = pad(now.getUTCHours());
+    const minutes = pad(now.getUTCMinutes());
+    const seconds = pad(now.getUTCSeconds());
+
+    const timestamp = `${year}${month}${day}_${hours}${minutes}${seconds}`;
+
+    const randomSuffix = Math.random().toString(36).slice(2, 6); // 4 alphanumeric chars
+
+    return `test_${timestamp}_${randomSuffix}`;
+  }
 }

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

@@ -231,29 +231,4 @@ export class NodePostgresProvider extends DatabaseProvider {
       }
     }
   }
-
-  // -------------------------------------------------------------------------------------------------------------------
-
-  /**
-   * For testing purposes, generate a unique schema name.
-   * The schema name will be generated based on the current date and time.
-   * It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-   */
-  protected generateTestSchemaName(): string {
-    const pad = (n: number) => n.toString().padStart(2, "0");
-
-    const now = new Date();
-    const year = now.getUTCFullYear();
-    const month = pad(now.getUTCMonth() + 1);
-    const day = pad(now.getUTCDate());
-    const hours = pad(now.getUTCHours());
-    const minutes = pad(now.getUTCMinutes());
-    const seconds = pad(now.getUTCSeconds());
-
-    const timestamp = `${year}${month}${day}_${hours}${minutes}${seconds}`;
-
-    const randomSuffix = Math.random().toString(36).slice(2, 6); // 4 alphanumeric chars
-
-    return `test_${timestamp}_${randomSuffix}`;
-  }
 }