alepha 0.14.0 → 0.14.2

package/dist/orm/index.d.ts

@@ -6,18 +6,22 @@ import { BuildColumns, BuildExtraConfigColumns, SQL, SQLWrapper, sql } from "dri
 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 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 { SQL as SQL$1 } from "bun";
+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 { PgTransactionConfig } from "drizzle-orm/pg-core/session";
 import * as DrizzleKit from "drizzle-kit/api";
-import * as typebox1 from "typebox";
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
+import * as typebox1 from "typebox";
 export * from "drizzle-orm/pg-core";
 
 //#region ../../src/orm/schemas/insertSchema.d.ts
@@ -767,7 +771,7 @@ type PgRelation<Base extends TObject> = {
 //#region ../../src/orm/interfaces/PgQueryWhere.d.ts
 type PgQueryWhere<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = (PgQueryWhereOperators<T> & PgQueryWhereConditions<T>) | (PgQueryWhereRelations<Relations> & PgQueryWhereOperators<T> & PgQueryWhereConditions<T, Relations>);
 type PgQueryWhereOrSQL<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = SQLWrapper | PgQueryWhere<T, Relations>;
-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) };
+type PgQueryWhereOperators<T extends TObject> = { [Key in keyof Static<T>]?: FilterOperators<Static<T>[Key]> | Static<T>[Key] };
 type PgQueryWhereConditions<T extends TObject, Relations extends PgRelationMap<TObject> | undefined = undefined> = {
   /**
    * Combine a list of conditions with the `and` operator. Conditions
@@ -838,10 +842,6 @@ type PgQueryWhereConditions<T extends TObject, Relations extends PgRelationMap<T
   exists?: SQLWrapper;
 };
 type PgQueryWhereRelations<Relations extends PgRelationMap<TObject> | undefined = undefined> = Relations extends PgRelationMap<TObject> ? { [K in keyof Relations]?: PgQueryWhere<Relations[K]["join"]["schema"], Relations[K]["with"]> } : {};
-/**
- * Recursively allow nested queries for JSONB object/array types
- */
-type NestedJsonbQuery<T> = T extends object ? T extends Array<infer U> ? U extends object ? { [K in keyof U]?: FilterOperators<U[K]> | U[K] } : FilterOperators<U> | U : { [K in keyof T]?: FilterOperators<T[K]> | T[K] | (T[K] extends object ? NestedJsonbQuery<T[K]> : never) } : FilterOperators<T> | T;
 //#endregion
 //#region ../../src/orm/helpers/parseQueryString.d.ts
 /**
@@ -1119,84 +1119,16 @@ declare abstract class DatabaseProvider {
    * MUST be implemented by each provider
    */
   protected abstract executeMigrations(migrationsFolder: string): Promise<void>;
-}
-//#endregion
-//#region ../../src/orm/services/PgJsonQueryManager.d.ts
-/**
- * Manages JSONB query generation for nested object and array queries in PostgreSQL.
- * This class handles complex nested queries using PostgreSQL's JSONB operators.
- */
-declare class PgJsonQueryManager {
-  /**
-   * Check if a query contains nested JSONB queries.
-   * A nested query is when the value is an object with operator keys.
-   */
-  hasNestedQuery(where: PgQueryWhere<TObject>): boolean;
-  /**
-   * Build a JSONB query condition for nested object queries.
-   * Supports deep nesting like: { profile: { contact: { email: { eq: "test@example.com" } } } }
-   *
-   * @param column The JSONB column
-   * @param path The path to the nested property (e.g., ['profile', 'contact', 'email'])
-   * @param operator The filter operator (e.g., { eq: "test@example.com" })
-   * @param dialect Database dialect (postgresql or sqlite)
-   * @param columnSchema Optional schema of the JSON column for type inference
-   * @returns SQL condition
-   */
-  buildJsonbCondition(column: PgColumn, path: string[], operator: FilterOperators<any>, dialect: "postgresql" | "sqlite", columnSchema?: any): SQL | undefined;
-  /**
-   * Build JSONB array query conditions.
-   * Supports queries like: { addresses: { city: { eq: "Wonderland" } } }
-   * which translates to: EXISTS (SELECT 1 FROM jsonb_array_elements(addresses) elem WHERE elem->>'city' = 'Wonderland')
-   *
-   * @param dialect Database dialect (postgresql or sqlite)
-   * Note: SQLite array queries are not yet supported
-   */
-  buildJsonbArrayCondition(column: PgColumn, path: string[], arrayPath: string, operator: FilterOperators<any>, dialect: "postgresql" | "sqlite"): SQL | undefined;
-  /**
-   * Apply a filter operator to a JSONB value.
-   * @param dialect Database dialect for appropriate casting syntax
-   * @param fieldType Optional field type from schema for smart casting
-   */
-  private applyOperatorToJsonValue;
-  /**
-   * Parse a nested query object and extract the path and operator.
-   * For example: { profile: { contact: { email: { eq: "test@example.com" } } } }
-   * Returns: { path: ['profile', 'contact', 'email'], operator: { eq: "test@example.com" } }
-   */
-  parseNestedQuery(nestedQuery: any, currentPath?: string[]): Array<{
-    path: string[];
-    operator: FilterOperators<any>;
-  }>;
-  /**
-   * Determine if a property is a JSONB column based on the schema.
-   * A column is JSONB if it's defined as an object or array in the TypeBox schema.
-   */
-  isJsonbColumn(schema: TObject, columnName: string): boolean;
-  /**
-   * Check if an array property contains primitive types (string, number, boolean, etc.)
-   * rather than objects. Primitive arrays should use native Drizzle operators.
-   * @returns true if the array contains primitives, false if it contains objects
-   */
-  isPrimitiveArray(schema: TObject, columnName: string): boolean;
-  /**
-   * Get the type of a field by navigating through a schema path.
-   * Used for smart type casting in SQL queries.
-   *
-   * @param columnSchema The schema of the JSON column (e.g., t.object({ age: t.integer() }))
-   * @param path The path to navigate (e.g., ['contact', 'email'])
-   * @returns The type string (e.g., 'integer', 'number', 'string') or undefined if not found
-   */
-  private getFieldType;
   /**
-   * Check if a nested path points to an array property.
+   * 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`.
    */
-  isArrayProperty(schema: TObject, path: string[]): boolean;
+  protected generateTestSchemaName(): string;
 }
 //#endregion
 //#region ../../src/orm/services/QueryManager.d.ts
 declare class QueryManager {
-  protected readonly jsonQueryManager: PgJsonQueryManager;
   protected readonly alepha: Alepha;
   /**
    * Convert a query object to a SQL query.
@@ -1207,10 +1139,6 @@ declare class QueryManager {
     joins?: PgJoin[];
     dialect: "postgresql" | "sqlite";
   }): SQL | undefined;
-  /**
-   * Build a JSONB query for nested object/array queries.
-   */
-  protected buildJsonbQuery(column: PgColumn, nestedQuery: any, schema: TObject, columnName: string, dialect: "postgresql" | "sqlite"): SQL | undefined;
   /**
    * Check if an object has any filter operator properties.
    */
@@ -1698,6 +1626,218 @@ 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<alepha1.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/PostgresModelBuilder.d.ts
+declare class PostgresModelBuilder extends ModelBuilder {
+  protected schemas: Map<string, drizzle_orm_pg_core0.PgSchema<string>>;
+  protected getPgSchema(name: string): any;
+  buildTable(entity: EntityPrimitive<any>, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  buildSequence(sequence: SequencePrimitive, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Get PostgreSQL-specific config builder for the table.
+   */
+  protected getTableConfig(entity: EntityPrimitive, tables: Map<string, unknown>): ((self: BuildExtraConfigColumns<string, any, "pg">) => PgTableExtraConfigValue[]) | undefined;
+  schemaToPgColumns: <T extends TObject>(tableName: string, schema: T, nsp: PgSchema, enums: Map<string, unknown>, tables: Map<string, unknown>) => FromSchema<T>;
+  mapFieldToColumn: (tableName: string, fieldName: string, value: TSchema, nsp: PgSchema, enums: Map<string, any>) => any;
+  /**
+   * Map a string to a PG column.
+   *
+   * @param key The key of the field.
+   * @param value The value of the field.
+   */
+  mapStringToColumn: (key: string, value: TSchema) => drizzle_orm_pg_core0.PgUUIDBuilderInitial<string> | drizzle_orm_pg_core0.PgCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "PgCustomColumn";
+    data: Buffer<ArrayBufferLike>;
+    driverParam: unknown;
+    enumValues: undefined;
+  }> | 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: alepha1.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: alepha1.TOptional<alepha1.TString>;
+  /**
+   * In addition to the DATABASE_URL, you can specify the postgres schema name.
+   */
+  POSTGRES_SCHEMA: alepha1.TOptional<alepha1.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_logger0.Logger;
+  protected readonly env: {
+    DATABASE_URL?: string | undefined;
+    POSTGRES_SCHEMA?: string | undefined;
+  };
+  protected readonly kit: DrizzleKitProvider;
+  protected readonly builder: PostgresModelBuilder;
+  protected client?: SQL$1;
+  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: alepha1.HookPrimitive<"start">;
+  protected readonly onStop: alepha1.HookPrimitive<"stop">;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  protected migrate: alepha_lock0.LockPrimitive<() => Promise<void>>;
+}
+//#endregion
 //#region ../../src/orm/services/SqliteModelBuilder.d.ts
 declare class SqliteModelBuilder extends ModelBuilder {
   buildTable(entity: EntityPrimitive<any>, options: {
@@ -1754,10 +1894,10 @@ declare class SqliteModelBuilder extends ModelBuilder {
     name: string;
     dataType: "custom";
     columnType: "SQLiteCustomColumn";
-    data: Record<string, unknown>;
+    data: typebox1.StaticRecord<[], "Decode", {}, {}, string, TSchema>;
     driverParam: string;
     enumValues: undefined;
-  }>, Record<string, unknown>> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+  }>, typebox1.StaticRecord<[], "Decode", {}, {}, string, TSchema>> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
     name: string;
     dataType: "custom";
     columnType: "SQLiteCustomColumn";
@@ -1852,6 +1992,65 @@ declare class SqliteModelBuilder extends ModelBuilder {
 }
 type SchemaToSqliteBuilder<T extends TObject> = { [key in keyof T["properties"]]: SQLiteColumnBuilderBase };
 //#endregion
+//#region ../../src/orm/providers/drivers/BunSqliteProvider.d.ts
+/**
+ * Configuration options for the Bun SQLite database provider.
+ */
+declare const bunSqliteOptions: alepha1.Atom<alepha1.TObject<{
+  path: alepha1.TOptional<alepha1.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_logger0.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: alepha1.HookPrimitive<"start">;
+  protected readonly onStop: alepha1.HookPrimitive<"stop">;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
+}
+//#endregion
 //#region ../../src/orm/providers/drivers/CloudflareD1Provider.d.ts
 /**
  * D1Database interface matching Cloudflare's D1 API.
@@ -1924,41 +2123,6 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   protected runTestMigration(): Promise<void>;
 }
 //#endregion
-//#region ../../src/orm/services/PostgresModelBuilder.d.ts
-declare class PostgresModelBuilder extends ModelBuilder {
-  protected schemas: Map<string, drizzle_orm_pg_core0.PgSchema<string>>;
-  protected getPgSchema(name: string): any;
-  buildTable(entity: EntityPrimitive<any>, options: {
-    tables: Map<string, unknown>;
-    enums: Map<string, unknown>;
-    schema: string;
-  }): void;
-  buildSequence(sequence: SequencePrimitive, options: {
-    sequences: Map<string, unknown>;
-    schema: string;
-  }): void;
-  /**
-   * Get PostgreSQL-specific config builder for the table.
-   */
-  protected getTableConfig(entity: EntityPrimitive, tables: Map<string, unknown>): ((self: BuildExtraConfigColumns<string, any, "pg">) => PgTableExtraConfigValue[]) | undefined;
-  schemaToPgColumns: <T extends TObject>(tableName: string, schema: T, nsp: PgSchema, enums: Map<string, unknown>, tables: Map<string, unknown>) => FromSchema<T>;
-  mapFieldToColumn: (tableName: string, fieldName: string, value: TSchema, nsp: PgSchema, enums: Map<string, any>) => any;
-  /**
-   * Map a string to a PG column.
-   *
-   * @param key The key of the field.
-   * @param value The value of the field.
-   */
-  mapStringToColumn: (key: string, value: TSchema) => drizzle_orm_pg_core0.PgUUIDBuilderInitial<string> | drizzle_orm_pg_core0.PgCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "PgCustomColumn";
-    data: Buffer<ArrayBufferLike>;
-    driverParam: unknown;
-    enumValues: undefined;
-  }> | 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/NodePostgresProvider.d.ts
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -2020,12 +2184,6 @@ declare class NodePostgresProvider extends DatabaseProvider {
    */
   protected getClientOptions(): postgres.Options<any>;
   protected ssl(url: URL): "require" | "allow" | "prefer" | "verify-full" | undefined;
-  /**
-   * 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;
 }
 //#endregion
 //#region ../../src/orm/providers/drivers/NodeSqliteProvider.d.ts
@@ -2067,89 +2225,6 @@ declare class NodeSqliteProvider extends DatabaseProvider {
   protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 //#endregion
-//#region ../../src/orm/providers/PostgresTypeProvider.d.ts
-declare class PostgresTypeProvider {
-  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<alepha1.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 RepositoryPrimitive#paginate} method.
-   */
-  readonly page: <T extends TObject>(resource: T, options?: TObjectOptions) => TPage<T>;
-}
-declare const pg: PostgresTypeProvider;
-//#endregion
 //#region ../../src/orm/providers/RepositoryProvider.d.ts
 declare class RepositoryProvider {
   protected readonly alepha: Alepha;
@@ -2249,21 +2324,25 @@ declare module "alepha" {
  * 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.
@@ -2286,5 +2365,5 @@ declare module "alepha" {
  */
 declare const AlephaPostgres: alepha1.Service<alepha1.Module>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, CloudflareD1Provider, D1Database, D1ExecResult, D1PreparedStatement, D1Result, DatabaseProvider, 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, PostgresTypeProvider, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequencePrimitive, SequencePrimitiveOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, 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