alepha 0.14.4 → 0.15.1

package/dist/orm/index.d.ts

@@ -1,22 +1,26 @@
-import * as alepha2 from "alepha";
+import { n as __reExport, t as __exportAll } from "./chunk-DH6iiROE.js";
+import * as alepha34 from "alepha";
 import { Alepha, AlephaError, KIND, Page, Page as Page$1, PageQuery, PageQuery as PageQuery$1, Primitive, Service, Static, StaticEncode, TBigInt, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TPage, TSchema, TString, TStringOptions, TUnion, TUnsafe, pageQuerySchema, pageSchema } from "alepha";
 import { DateTime, DateTimeProvider } from "alepha/datetime";
-import * as drizzle_orm0 from "drizzle-orm";
-import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, sql } from "drizzle-orm";
 import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
 import { LockConfig, LockStrength, PgColumn, PgColumnBuilderBase, PgDatabase, PgInsertValue, PgSchema, PgSelectBase, PgSequenceOptions, PgTableExtraConfigValue, PgTableWithColumns, PgTransaction, UpdateDeleteAction } from "drizzle-orm/pg-core";
-import * as alepha_logger0 from "alepha/logger";
+import * as drizzle_orm0 from "drizzle-orm";
+import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, sql } from "drizzle-orm";
+import * as alepha_logger4 from "alepha/logger";
+import * as alepha_lock0 from "alepha/lock";
 import * as pg$1 from "drizzle-orm/sqlite-core";
 import { SQLiteColumnBuilderBase } from "drizzle-orm/sqlite-core";
-import * as alepha_lock0 from "alepha/lock";
 import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
 import * as alepha_retry0 from "alepha/retry";
+import { Database } from "bun:sqlite";
+import { BunSQLDatabase } from "drizzle-orm/bun-sql";
+import { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
 import { DrizzleD1Database } from "drizzle-orm/d1";
 import { DatabaseSync } from "node:sqlite";
+import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 import { PgTransactionConfig } from "drizzle-orm/pg-core/session";
 import * as DrizzleKit from "drizzle-kit/api";
-import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 import * as typebox1 from "typebox";
 export * from "drizzle-orm/pg-core";
 
@@ -69,7 +73,7 @@ declare const updateSchema: <T extends TObject>(schema: T) => TObjectUpdate<T>;
  * ```
  */
 declare const $entity: {
-  <TSchema$1 extends TObject>(options: EntityPrimitiveOptions<TSchema$1>): EntityPrimitive<TSchema$1>;
+  <TSchema extends TObject>(options: EntityPrimitiveOptions<TSchema>): EntityPrimitive<TSchema>;
   [KIND]: typeof EntityPrimitive;
 };
 interface EntityPrimitiveOptions<T extends TObject, Keys = keyof Static<T>> {
@@ -275,13 +279,6 @@ declare class DbConflictError extends DbError {
   readonly status = 409;
 }
 //#endregion
-//#region ../../src/orm/errors/DbEntityNotFoundError.d.ts
-declare class DbEntityNotFoundError extends DbError {
-  readonly name = "DbEntityNotFoundError";
-  readonly status = 404;
-  constructor(entityName: string);
-}
-//#endregion
 //#region ../../src/orm/errors/DbMigrationError.d.ts
 declare class DbMigrationError extends DbError {
   readonly name = "DbMigrationError";
@@ -299,6 +296,13 @@ declare class DbVersionMismatchError extends DbError {
   constructor(table: string, id: any);
 }
 //#endregion
+//#region ../../src/orm/errors/DbEntityNotFoundError.d.ts
+declare class DbEntityNotFoundError extends DbError {
+  readonly name = "DbEntityNotFoundError";
+  readonly status = 404;
+  constructor(entityName: string);
+}
+//#endregion
 //#region ../../src/orm/interfaces/FilterOperators.d.ts
 interface FilterOperators<TValue> {
   /**
@@ -939,6 +943,116 @@ interface PgAttrField {
   one?: boolean;
 }
 //#endregion
+//#region ../../src/orm/providers/DatabaseTypeProvider.d.ts
+declare class DatabaseTypeProvider {
+  readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
+  /**
+   * Creates a primary key with an identity column.
+   */
+  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  /**
+   * Creates a primary key with a big identity column. (default)
+   */
+  readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
+  /**
+   * Creates a primary key with a UUID column.
+   */
+  readonly uuidPrimaryKey: () => PgAttr<PgAttr<TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
+  /**
+   * Creates a primary key for a given type. Supports:
+   * - `t.integer()` -> PG INT (default)
+   * - `t.bigint()` -> PG BIGINT
+   * - `t.uuid()` -> PG UUID
+   */
+  primaryKey(): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TString, options?: TStringOptions): PgAttr<PgAttr<TString, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TInteger, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TNumber, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TNumber, PgPrimaryKey>, PgDefault>;
+  primaryKey(type: TBigInt, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TBigInt, PgPrimaryKey>, PgDefault>;
+  /**
+   * Wrap a schema with "default" attribute.
+   * This is used to set a default value for a column in the database.
+   */
+  readonly default: <T extends TSchema>(type: T, value?: Static<T>) => PgAttr<T, PgDefault>;
+  /**
+   * Creates a column 'version'.
+   *
+   * This is used to track the version of a row in the database.
+   *
+   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryPrimitive#save}.
+   *
+   * @see {@link RepositoryPrimitive#save}
+   * @see {@link PgVersionMismatchError}
+   */
+  readonly version: (options?: TNumberOptions) => PgAttr<PgAttr<TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
+  /**
+   * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
+   */
+  readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  /**
+   * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
+   */
+  readonly updatedAt: (options?: TStringOptions) => PgAttr<PgAttr<TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  /**
+   * Creates a column Deleted At for soft delete functionality.
+   * This is used to mark rows as deleted without actually removing them from the database.
+   * The column is nullable - NULL means not deleted, timestamp means deleted.
+   */
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<alepha34.TOptional<TString>, typeof PG_DELETED_AT>;
+  /**
+   * Creates a Postgres ENUM type.
+   *
+   * > By default, `t.enum()` is mapped to a TEXT column in Postgres.
+   * > Using this method, you can create a real ENUM type in the database.
+   *
+   * @example
+   * ```ts
+   * const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
+   * ```
+   */
+  readonly enum: <T extends string[]>(values: [...T], pgEnumOptions?: PgEnumOptions, typeOptions?: TStringOptions) => PgAttr<TUnsafe<T[number]>, typeof PG_ENUM>;
+  /**
+   * Creates a reference to another table or schema. Basically a foreign key.
+   */
+  readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
+    onUpdate?: UpdateDeleteAction$1;
+    onDelete?: UpdateDeleteAction$1;
+  }) => PgAttr<T, PgRef>;
+  /**
+   * Creates a page schema for a given object schema.
+   * It's used by {@link Repository#paginate} method.
+   */
+  readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
+}
+/**
+ * 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(),
+ * });
+ * ```
+ */
+declare const db: DatabaseTypeProvider;
+/**
+ * @deprecated Use `db` instead.
+ */
+declare const pg: DatabaseTypeProvider;
+//#endregion
+//#region ../../src/orm/schemas/legacyIdSchema.d.ts
+/**
+ * @deprecated Use `pg.primaryKey()` instead.
+ */
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<alepha34.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+//#endregion
 //#region ../../src/orm/primitives/$sequence.d.ts
 /**
  * Creates a PostgreSQL sequence primitive for generating unique numeric values.
@@ -1022,7 +1136,7 @@ declare abstract class ModelBuilder {
 //#endregion
 //#region ../../src/orm/providers/DrizzleKitProvider.d.ts
 declare class DrizzleKitProvider {
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly alepha: Alepha;
   /**
    * Synchronize database with current schema definitions.
@@ -1058,11 +1172,11 @@ declare class DrizzleKitProvider {
    */
   importDrizzleKit(): typeof DrizzleKit;
 }
-declare const devMigrationsSchema: alepha2.TObject<{
-  id: alepha2.TNumber;
-  name: alepha2.TString;
-  snapshot: alepha2.TString;
-  created_at: alepha2.TString;
+declare const devMigrationsSchema: alepha34.TObject<{
+  id: alepha34.TNumber;
+  name: alepha34.TString;
+  snapshot: alepha34.TString;
+  created_at: alepha34.TString;
 }>;
 type DevMigrations = Static<typeof devMigrationsSchema>;
 //#endregion
@@ -1070,7 +1184,7 @@ type DevMigrations = Static<typeof devMigrationsSchema>;
 type SQLLike = SQLWrapper | string;
 declare abstract class DatabaseProvider {
   protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected abstract readonly builder: ModelBuilder;
   protected abstract readonly kit: DrizzleKitProvider;
   abstract readonly db: PgDatabase<any>;
@@ -1080,6 +1194,7 @@ declare abstract class DatabaseProvider {
   readonly tables: Map<string, unknown>;
   readonly sequences: Map<string, unknown>;
   get name(): string;
+  get driver(): string;
   get schema(): string;
   table<T extends TObject>(entity: EntityPrimitive<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
   registerEntity(entity: EntityPrimitive): void;
@@ -1187,7 +1302,7 @@ declare class QueryManager {
   createPagination<T>(entities: T[], limit?: number, offset?: number, sort?: Array<{
     column: string;
     direction: "asc" | "desc";
-  }>): alepha2.Page<T>;
+  }>): alepha34.Page<T>;
 }
 interface PgJoin {
   table: string;
@@ -1221,10 +1336,12 @@ declare class PgRelationManager {
 declare abstract class Repository<T extends TObject> {
   readonly entity: EntityPrimitive<T>;
   readonly provider: DatabaseProvider;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly relationManager: PgRelationManager;
   protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
+  static of<T extends TObject>(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider): new () => Repository<T>;
   constructor(entity: EntityPrimitive<T>, provider?: typeof DatabaseProvider);
   /**
    * Represents the primary key of the table.
@@ -1622,110 +1739,6 @@ interface TransactionPrimitiveOptions<T extends any[], R> {
 }
 type TransactionContext = PgTransaction<any, any, any>;
 //#endregion
-//#region ../../src/orm/providers/DatabaseTypeProvider.d.ts
-declare class DatabaseTypeProvider {
-  readonly attr: <T extends TSchema, Attr extends PgSymbolKeys>(type: T, attr: Attr, value?: PgSymbols[Attr]) => PgAttr<T, Attr>;
-  /**
-   * Creates a primary key with an identity column.
-   */
-  readonly identityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TInteger, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
-  /**
-   * Creates a primary key with a big identity column. (default)
-   */
-  readonly bigIdentityPrimaryKey: (identity?: PgIdentityOptions, options?: TNumberOptions) => PgAttr<PgAttr<PgAttr<TNumber, typeof PG_PRIMARY_KEY>, typeof PG_IDENTITY>, typeof PG_DEFAULT>;
-  /**
-   * Creates a primary key with a UUID column.
-   */
-  readonly uuidPrimaryKey: () => PgAttr<PgAttr<TString, typeof PG_PRIMARY_KEY>, typeof PG_DEFAULT>;
-  /**
-   * Creates a primary key for a given type. Supports:
-   * - `t.integer()` -> PG INT (default)
-   * - `t.bigint()` -> PG BIGINT
-   * - `t.uuid()` -> PG UUID
-   */
-  primaryKey(): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
-  primaryKey(type: TString, options?: TStringOptions): PgAttr<PgAttr<TString, PgPrimaryKey>, PgDefault>;
-  primaryKey(type: TInteger, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TInteger, PgPrimaryKey>, PgDefault>;
-  primaryKey(type: TNumber, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TNumber, PgPrimaryKey>, PgDefault>;
-  primaryKey(type: TBigInt, options?: TNumberOptions, identity?: PgIdentityOptions): PgAttr<PgAttr<TBigInt, PgPrimaryKey>, PgDefault>;
-  /**
-   * Wrap a schema with "default" attribute.
-   * This is used to set a default value for a column in the database.
-   */
-  readonly default: <T extends TSchema>(type: T, value?: Static<T>) => PgAttr<T, PgDefault>;
-  /**
-   * Creates a column 'version'.
-   *
-   * This is used to track the version of a row in the database.
-   *
-   * You can use it for optimistic concurrency control (OCC) with {@link RepositoryPrimitive#save}.
-   *
-   * @see {@link RepositoryPrimitive#save}
-   * @see {@link PgVersionMismatchError}
-   */
-  readonly version: (options?: TNumberOptions) => PgAttr<PgAttr<TInteger, typeof PG_VERSION>, typeof PG_DEFAULT>;
-  /**
-   * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
-   */
-  readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<TString, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
-  /**
-   * Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
-   */
-  readonly updatedAt: (options?: TStringOptions) => PgAttr<PgAttr<TString, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
-  /**
-   * Creates a column Deleted At for soft delete functionality.
-   * This is used to mark rows as deleted without actually removing them from the database.
-   * The column is nullable - NULL means not deleted, timestamp means deleted.
-   */
-  readonly deletedAt: (options?: TStringOptions) => PgAttr<alepha2.TOptional<TString>, typeof PG_DELETED_AT>;
-  /**
-   * Creates a Postgres ENUM type.
-   *
-   * > By default, `t.enum()` is mapped to a TEXT column in Postgres.
-   * > Using this method, you can create a real ENUM type in the database.
-   *
-   * @example
-   * ```ts
-   * const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
-   * ```
-   */
-  readonly enum: <T extends string[]>(values: [...T], pgEnumOptions?: PgEnumOptions, typeOptions?: TStringOptions) => PgAttr<TUnsafe<T[number]>, typeof PG_ENUM>;
-  /**
-   * Creates a reference to another table or schema. Basically a foreign key.
-   */
-  readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
-    onUpdate?: UpdateDeleteAction$1;
-    onDelete?: UpdateDeleteAction$1;
-  }) => PgAttr<T, PgRef>;
-  /**
-   * Creates a page schema for a given object schema.
-   * It's used by {@link Repository#paginate} method.
-   */
-  readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
-}
-/**
- * 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(),
- * });
- * ```
- */
-declare const db: DatabaseTypeProvider;
-/**
- * @deprecated Use `db` instead.
- */
-declare const pg: DatabaseTypeProvider;
-//#endregion
 //#region ../../src/orm/services/SqliteModelBuilder.d.ts
 declare class SqliteModelBuilder extends ModelBuilder {
   buildTable(entity: EntityPrimitive<any>, options: {
@@ -1926,7 +1939,7 @@ interface D1ExecResult {
  */
 declare class CloudflareD1Provider extends DatabaseProvider {
   protected readonly kit: DrizzleKitProvider;
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly builder: SqliteModelBuilder;
   protected readonly env: {
     DATABASE_URL: string;
@@ -1934,11 +1947,12 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   protected d1?: D1Database;
   protected drizzleDb?: DrizzleD1Database;
   get name(): string;
+  get driver(): string;
   readonly dialect = "sqlite";
   get url(): string;
   get db(): PgDatabase<any>;
   execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
-  protected readonly onStart: alepha2.HookPrimitive<"start">;
+  protected readonly onStart: alepha34.HookPrimitive<"start">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
   /**
    * Override development migration to skip sync (not supported on D1).
@@ -1952,6 +1966,28 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   protected runTestMigration(): Promise<void>;
 }
 //#endregion
+//#region ../../src/orm/providers/RepositoryProvider.d.ts
+declare class RepositoryProvider {
+  protected readonly alepha: Alepha;
+  protected readonly registry: Map<EntityPrimitive<any>, Service<Repository<any>>>;
+  getRepositories(provider?: DatabaseProvider): Repository<TObject<alepha34.TProperties>>[];
+  getRepository<T extends TObject>(entity: EntityPrimitive<T>): Repository<T>;
+  createClassRepository<T extends TObject>(entity: EntityPrimitive<T>): Service<Repository<T>>;
+}
+//#endregion
+//#region ../../src/orm/types/schema.d.ts
+/**
+ * Postgres schema type.
+ */
+declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+  name: string;
+  dataType: "custom";
+  columnType: "PgCustomColumn";
+  data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
+  driverParam: string;
+  enumValues: undefined;
+}>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
+//#endregion
 //#region ../../src/orm/services/PostgresModelBuilder.d.ts
 declare class PostgresModelBuilder extends ModelBuilder {
   protected schemas: Map<string, drizzle_orm_pg_core0.PgSchema<string>>;
@@ -1987,11 +2023,143 @@ declare class PostgresModelBuilder extends ModelBuilder {
   }> | drizzle_orm_pg_core0.PgTimestampStringBuilderInitial<string> | drizzle_orm_pg_core0.PgDateStringBuilderInitial<string> | drizzle_orm_pg_core0.PgTextBuilderInitial<string, [string, ...string[]]>;
 }
 //#endregion
+//#region ../../src/orm/providers/drivers/BunPostgresProvider.d.ts
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema$1>> {}
+}
+declare const envSchema$1: alepha34.TObject<{
+  /**
+   * 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: alepha34.TOptional<alepha34.TString>;
+  /**
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   */
+  POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
+}>;
+/**
+ * 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,
+ * });
+ * ```
+ */
+declare class BunPostgresProvider extends DatabaseProvider {
+  protected readonly log: alepha_logger4.Logger;
+  protected readonly env: {
+    DATABASE_URL?: string | undefined;
+    POSTGRES_SCHEMA?: string | undefined;
+  };
+  protected readonly kit: DrizzleKitProvider;
+  protected readonly builder: PostgresModelBuilder;
+  protected client?: Bun.SQL;
+  protected bunDb?: BunSQLDatabase;
+  readonly dialect = "postgresql";
+  get name(): string;
+  /**
+   * In testing mode, the schema name will be generated and deleted after the test.
+   */
+  protected schemaForTesting: string | undefined;
+  get url(): string;
+  /**
+   * Execute a SQL statement.
+   */
+  execute(statement: SQLLike): Promise<Array<Record<string, unknown>>>;
+  /**
+   * Get Postgres schema used by this provider.
+   */
+  get schema(): string;
+  /**
+   * Get the Drizzle Postgres database instance.
+   */
+  get db(): PgDatabase<any>;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
+  protected readonly onStart: alepha34.HookPrimitive<"start">;
+  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  protected migrateLock: alepha_lock0.LockPrimitive<() => Promise<void>>;
+}
+//#endregion
+//#region ../../src/orm/providers/drivers/BunSqliteProvider.d.ts
+/**
+ * Configuration options for the Bun SQLite database provider.
+ */
+declare const bunSqliteOptions: alepha34.Atom<alepha34.TObject<{
+  path: alepha34.TOptional<alepha34.TString>;
+}>, "alepha.postgres.bun-sqlite.options">;
+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:",
+ * }));
+ * ```
+ */
+declare class BunSqliteProvider extends DatabaseProvider {
+  protected readonly kit: DrizzleKitProvider;
+  protected readonly log: alepha_logger4.Logger;
+  protected readonly env: {
+    DATABASE_URL?: string | undefined;
+  };
+  protected readonly builder: SqliteModelBuilder;
+  protected readonly options: Readonly<{
+    path?: string | undefined;
+  }>;
+  protected sqlite?: Database;
+  protected bunDb?: BunSQLiteDatabase;
+  get name(): string;
+  readonly dialect = "sqlite";
+  get url(): string;
+  get db(): PgDatabase<any>;
+  execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
+  protected readonly onStart: alepha34.HookPrimitive<"start">;
+  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
+}
+//#endregion
 //#region ../../src/orm/providers/drivers/NodePostgresProvider.d.ts
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-declare const envSchema: alepha2.TObject<{
+declare const envSchema: alepha34.TObject<{
   /**
    * Main configuration for database connection.
    * Accept a string in the format of a Postgres connection URL.
@@ -1999,17 +2167,17 @@ declare const envSchema: alepha2.TObject<{
    * or
    * Example: postgres://user:password@localhost:5432/database?sslmode=require
    */
-  DATABASE_URL: alepha2.TOptional<alepha2.TString>;
+  DATABASE_URL: alepha34.TOptional<alepha34.TString>;
   /**
    * In addition to the DATABASE_URL, you can specify the postgres schema name.
    *
    * It will monkey patch drizzle tables.
    */
-  POSTGRES_SCHEMA: alepha2.TOptional<alepha2.TString>;
+  POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
 }>;
 declare class NodePostgresProvider extends DatabaseProvider {
   static readonly SSL_MODES: readonly ["require", "allow", "prefer", "verify-full"];
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
     POSTGRES_SCHEMA?: string | undefined;
@@ -2038,8 +2206,8 @@ declare class NodePostgresProvider extends DatabaseProvider {
    */
   get db(): PostgresJsDatabase;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
-  protected readonly onStart: alepha2.HookPrimitive<"start">;
-  protected readonly onStop: alepha2.HookPrimitive<"stop">;
+  protected readonly onStart: alepha34.HookPrimitive<"start">;
+  protected readonly onStop: alepha34.HookPrimitive<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrateLock: alepha_lock0.LockPrimitive<() => Promise<void>>;
@@ -2054,8 +2222,8 @@ declare class NodePostgresProvider extends DatabaseProvider {
 /**
  * Configuration options for the Node.js SQLite database provider.
  */
-declare const nodeSqliteOptions: alepha2.Atom<alepha2.TObject<{
-  path: alepha2.TOptional<alepha2.TString>;
+declare const nodeSqliteOptions: alepha34.Atom<alepha34.TObject<{
+  path: alepha34.TOptional<alepha34.TString>;
 }>, "alepha.postgres.node-sqlite.options">;
 type NodeSqliteProviderOptions = Static<typeof nodeSqliteOptions.schema>;
 declare module "alepha" {
@@ -2071,7 +2239,7 @@ declare module "alepha" {
  */
 declare class NodeSqliteProvider extends DatabaseProvider {
   protected readonly kit: DrizzleKitProvider;
-  protected readonly log: alepha_logger0.Logger;
+  protected readonly log: alepha_logger4.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
   };
@@ -2085,39 +2253,12 @@ declare class NodeSqliteProvider extends DatabaseProvider {
   get url(): string;
   execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
   readonly db: PgDatabase<any>;
-  protected readonly onStart: alepha2.HookPrimitive<"start">;
+  protected readonly onStart: alepha34.HookPrimitive<"start">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
-//#endregion
-//#region ../../src/orm/providers/RepositoryProvider.d.ts
-declare class RepositoryProvider {
-  protected readonly alepha: Alepha;
-  protected readonly registry: Map<EntityPrimitive<any>, Service<Repository<any>>>;
-  getRepositories(provider?: DatabaseProvider): Repository<TObject<alepha2.TProperties>>[];
-  getRepository<T extends TObject>(entity: EntityPrimitive<T>): Repository<T>;
-  createClassRepository<T extends TObject>(entity: EntityPrimitive<T>): Service<Repository<T>>;
+declare namespace index_d_exports {
+  export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BunPostgresProvider, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Page, PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 }
-//#endregion
-//#region ../../src/orm/schemas/legacyIdSchema.d.ts
-/**
- * @deprecated Use `pg.primaryKey()` instead.
- */
-declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<alepha2.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
-//#endregion
-//#region ../../src/orm/types/schema.d.ts
-/**
- * Postgres schema type.
- */
-declare const schema: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<drizzle_orm_pg_core0.PgCustomColumnBuilder<{
-  name: string;
-  dataType: "custom";
-  columnType: "PgCustomColumn";
-  data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
-  driverParam: string;
-  enumValues: undefined;
-}>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
-//#endregion
-//#region ../../src/orm/index.d.ts
 declare module "alepha" {
   interface Hooks {
     /**
@@ -2187,6 +2328,10 @@ declare module "alepha" {
 /**
  * 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";
@@ -2225,9 +2370,13 @@ declare module "alepha" {
  * @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
  */
-declare const AlephaPostgres: alepha2.Service<alepha2.Module>;
+declare const AlephaPostgres: alepha34.Service<alepha34.Module>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BunPostgresProvider, BunSqliteProvider, BunSqliteProviderOptions, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityPrimitive, EntityPrimitiveOptions, FilterOperators, FromSchema, NodePostgresProvider, NodeSqliteProvider, NodeSqliteProviderOptions, OrderBy, OrderByClause, OrderDirection, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, type Page, type PageQuery, PgAttr, PgAttrField, PgDefault, PgEnumOptions, PgIdentityOptions, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map