alepha 0.15.1 → 0.15.3

package/dist/orm/index.d.ts

@@ -1,5 +1,5 @@
 import { n as __reExport, t as __exportAll } from "./chunk-DH6iiROE.js";
-import * as alepha34 from "alepha";
+import * as alepha26 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_orm_pg_core0 from "drizzle-orm/pg-core";
@@ -18,12 +18,65 @@ 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 * as typebox0 from "typebox";
+import * as DrizzleKit from "drizzle-kit/api";
 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 * as typebox1 from "typebox";
 export * from "drizzle-orm/pg-core";
 
+//#region ../../src/orm/constants/PG_SYMBOLS.d.ts
+declare const PG_DEFAULT: unique symbol;
+declare const PG_PRIMARY_KEY: unique symbol;
+declare const PG_CREATED_AT: unique symbol;
+declare const PG_UPDATED_AT: unique symbol;
+declare const PG_DELETED_AT: unique symbol;
+declare const PG_VERSION: unique symbol;
+declare const PG_IDENTITY: unique symbol;
+declare const PG_ENUM: unique symbol;
+declare const PG_REF: unique symbol;
+/**
+ * @deprecated Use `PG_IDENTITY` instead.
+ */
+declare const PG_SERIAL: unique symbol;
+type PgDefault = typeof PG_DEFAULT;
+type PgRef = typeof PG_REF;
+type PgPrimaryKey = typeof PG_PRIMARY_KEY;
+type PgSymbols = {
+  [PG_DEFAULT]: {};
+  [PG_PRIMARY_KEY]: {};
+  [PG_CREATED_AT]: {};
+  [PG_UPDATED_AT]: {};
+  [PG_DELETED_AT]: {};
+  [PG_VERSION]: {};
+  [PG_IDENTITY]: PgIdentityOptions;
+  [PG_REF]: PgRefOptions;
+  [PG_ENUM]: PgEnumOptions;
+  /**
+   * @deprecated Use `PG_IDENTITY` instead.
+   */
+  [PG_SERIAL]: {};
+};
+type PgSymbolKeys = keyof PgSymbols;
+type PgIdentityOptions = {
+  mode: "always" | "byDefault";
+} & PgSequenceOptions & {
+  name?: string;
+};
+interface PgEnumOptions {
+  name?: string;
+  description?: string;
+}
+interface PgRefOptions {
+  ref: () => {
+    name: string;
+    entity: EntityPrimitive;
+  };
+  actions?: {
+    onUpdate?: UpdateDeleteAction;
+    onDelete?: UpdateDeleteAction;
+  };
+}
+//#endregion
 //#region ../../src/orm/schemas/insertSchema.d.ts
 /**
  * Transforms a TObject schema for insert operations.
@@ -214,57 +267,385 @@ type EntityColumn<T extends TObject> = {
 };
 type EntityColumns<T extends TObject> = { [key in keyof T["properties"]]: EntityColumn<T> };
 //#endregion
-//#region ../../src/orm/constants/PG_SYMBOLS.d.ts
-declare const PG_DEFAULT: unique symbol;
-declare const PG_PRIMARY_KEY: unique symbol;
-declare const PG_CREATED_AT: unique symbol;
-declare const PG_UPDATED_AT: unique symbol;
-declare const PG_DELETED_AT: unique symbol;
-declare const PG_VERSION: unique symbol;
-declare const PG_IDENTITY: unique symbol;
-declare const PG_ENUM: unique symbol;
-declare const PG_REF: unique symbol;
+//#region ../../src/orm/services/ModelBuilder.d.ts
 /**
- * @deprecated Use `PG_IDENTITY` instead.
+ * Database-specific table configuration functions
  */
-declare const PG_SERIAL: unique symbol;
-type PgDefault = typeof PG_DEFAULT;
-type PgRef = typeof PG_REF;
-type PgPrimaryKey = typeof PG_PRIMARY_KEY;
-type PgSymbols = {
-  [PG_DEFAULT]: {};
-  [PG_PRIMARY_KEY]: {};
-  [PG_CREATED_AT]: {};
-  [PG_UPDATED_AT]: {};
-  [PG_DELETED_AT]: {};
-  [PG_VERSION]: {};
-  [PG_IDENTITY]: PgIdentityOptions;
-  [PG_REF]: PgRefOptions;
-  [PG_ENUM]: PgEnumOptions;
+interface TableConfigBuilders<TConfig> {
+  index: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  uniqueIndex: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  unique: (name: string) => {
+    on: (...columns: any[]) => TConfig;
+  };
+  check: (name: string, sql: SQL) => TConfig;
+  foreignKey: (config: {
+    name: string;
+    columns: any[];
+    foreignColumns: any[];
+  }) => TConfig;
+}
+/**
+ * Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
+ * into drizzle models (tables, enums, sequences, etc...).
+ */
+declare abstract class ModelBuilder {
   /**
-   * @deprecated Use `PG_IDENTITY` instead.
+   * Build a table from an entity primitive.
    */
-  [PG_SERIAL]: {};
-};
-type PgSymbolKeys = keyof PgSymbols;
-type PgIdentityOptions = {
-  mode: "always" | "byDefault";
-} & PgSequenceOptions & {
-  name?: string;
+  abstract buildTable(entity: EntityPrimitive, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Build a sequence from a sequence primitive.
+   */
+  abstract buildSequence(sequence: SequencePrimitive, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Convert camelCase to snake_case for column names.
+   */
+  protected toColumnName(str: string): string;
+  /**
+   * Build the table configuration function for any database.
+   * This includes indexes, foreign keys, constraints, and custom config.
+   *
+   * @param entity - The entity primitive
+   * @param builders - Database-specific builder functions
+   * @param tableResolver - Function to resolve entity references to table columns
+   * @param customConfigHandler - Optional handler for custom config
+   */
+  protected buildTableConfig<TConfig, TSelf>(entity: EntityPrimitive, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
+}
+//#endregion
+//#region ../../src/orm/providers/DrizzleKitProvider.d.ts
+declare class DrizzleKitProvider {
+  protected readonly log: alepha_logger4.Logger;
+  protected readonly alepha: Alepha;
+  /**
+   * Synchronize database with current schema definitions.
+   *
+   * In development mode, it will generate and execute migrations based on the current state.
+   * In testing mode, it will generate migrations from scratch without applying them.
+   *
+   * Does nothing in production mode, you must handle migrations manually.
+   */
+  synchronize(provider: DatabaseProvider): Promise<void>;
+  /**
+   * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
+   */
+  generateMigration(provider: DatabaseProvider, prevSnapshot?: any): Promise<{
+    statements: string[];
+    models: Record<string, unknown>;
+    snapshot?: any;
+  }>;
+  /**
+   * Load all tables, enums, sequences, etc. from the provider's repositories.
+   */
+  getModels(provider: DatabaseProvider): Record<string, unknown>;
+  /**
+   * Load the migration snapshot from the database.
+   */
+  protected loadDevMigrations(provider: DatabaseProvider): Promise<DevMigrations | undefined>;
+  protected saveDevMigrations(provider: DatabaseProvider, curr: Record<string, any>, devMigrations?: DevMigrations): Promise<void>;
+  protected executeStatements(statements: string[], provider: DatabaseProvider, catchErrors?: boolean): Promise<void>;
+  protected createSchemaIfNotExists(provider: DatabaseProvider, schemaName: string): Promise<void>;
+  /**
+   * Try to load the official Drizzle Kit API.
+   * If not available, fallback to the local kit import.
+   */
+  importDrizzleKit(): typeof DrizzleKit;
+}
+declare const devMigrationsSchema: alepha26.TObject<{
+  id: alepha26.TNumber;
+  name: alepha26.TString;
+  snapshot: alepha26.TString;
+  created_at: alepha26.TString;
+}>;
+type DevMigrations = Static<typeof devMigrationsSchema>;
+//#endregion
+//#region ../../src/orm/providers/drivers/DatabaseProvider.d.ts
+type SQLLike = SQLWrapper | string;
+declare abstract class DatabaseProvider {
+  protected readonly alepha: Alepha;
+  protected readonly log: alepha_logger4.Logger;
+  protected abstract readonly builder: ModelBuilder;
+  protected abstract readonly kit: DrizzleKitProvider;
+  abstract readonly db: PgDatabase<any>;
+  abstract readonly dialect: "postgresql" | "sqlite";
+  abstract readonly url: string;
+  readonly enums: Map<string, unknown>;
+  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;
+  registerSequence(sequence: SequencePrimitive): void;
+  abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
+  run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
+  /**
+   * Get migrations folder path - can be overridden
+   */
+  protected getMigrationsFolder(): string;
+  /**
+   * Base migration orchestration - handles environment logic.
+   *
+   * Never runs in serverless mode - migrations should be applied during
+   * deployment, not at runtime (to avoid race conditions and timeouts).
+   */
+  migrate(): Promise<void>;
+  /**
+   * Production: run migrations from folder
+   */
+  protected runProductionMigration(migrationsFolder: string): Promise<void>;
+  /**
+   * Test: always synchronize
+   */
+  protected runTestMigration(): Promise<void>;
+  /**
+   * Development: default to synchronize (can be overridden)
+   */
+  protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
+  /**
+   * Common synchronization with error handling
+   */
+  protected synchronizeSchema(): Promise<void>;
+  /**
+   * Provider-specific migration execution
+   * 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;
+}
+//#endregion
+//#region ../../src/orm/primitives/$sequence.d.ts
+/**
+ * Creates a PostgreSQL sequence primitive for generating unique numeric values.
+ */
+declare const $sequence: {
+  (options?: SequencePrimitiveOptions): SequencePrimitive;
+  [KIND]: typeof SequencePrimitive;
 };
-interface PgEnumOptions {
+interface SequencePrimitiveOptions extends PgSequenceOptions {
+  /**
+   * The name of the sequence. If not provided, the property key will be used.
+   */
   name?: string;
-  description?: string;
+  provider?: DatabaseProvider;
 }
-interface PgRefOptions {
-  ref: () => {
+declare class SequencePrimitive extends Primitive<SequencePrimitiveOptions> {
+  readonly provider: DatabaseProvider;
+  onInit(): void;
+  get name(): string;
+  next(): Promise<number>;
+  current(): Promise<number>;
+  protected $provider(): DatabaseProvider;
+}
+//#endregion
+//#region ../../src/orm/services/SqliteModelBuilder.d.ts
+declare class SqliteModelBuilder extends ModelBuilder {
+  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 SQLite-specific config builder for the table.
+   */
+  protected getTableConfig(entity: EntityPrimitive, tables: Map<string, unknown>): ((self: BuildColumns<string, any, "sqlite">) => any) | undefined;
+  schemaToSqliteColumns: <T extends TObject>(tableName: string, schema: T, enums: Map<string, unknown>, tables: Map<string, unknown>) => SchemaToSqliteBuilder<T>;
+  mapFieldToSqliteColumn: (tableName: string, fieldName: string, value: TSchema, enums: Map<string, any>) => pg$1.SQLiteIntegerBuilderInitial<string> | pg$1.SQLiteNumericBuilderInitial<string> | pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
     name: string;
-    entity: EntityPrimitive;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: string;
+    enumValues: undefined;
+  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: number;
+    enumValues: undefined;
+  }> | pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: boolean;
+    driverParam: number;
+    enumValues: undefined;
+  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: {
+      [x: string]: unknown;
+      [x: number]: unknown;
+      [x: symbol]: unknown;
+    };
+    driverParam: string;
+    enumValues: undefined;
+  }>, {
+    [x: string]: unknown;
+    [x: number]: unknown;
+    [x: symbol]: unknown;
+  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: typebox0.StaticRecord<[], "Decode", {}, {}, string, TSchema>;
+    driverParam: string;
+    enumValues: undefined;
+  }>, typebox0.StaticRecord<[], "Decode", {}, {}, string, TSchema>> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: any;
+    driverParam: string;
+    enumValues: undefined;
+  }>, any> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: unknown[];
+    driverParam: string;
+    enumValues: undefined;
+  }>, unknown[]>;
+  mapStringToSqliteColumn: (key: string, value: TString) => pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: string;
+    enumValues: undefined;
+  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: string;
+    driverParam: number;
+    enumValues: undefined;
+  }>;
+  sqliteJson: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
+    name: string;
+    dataType: "custom";
+    columnType: "SQLiteCustomColumn";
+    data: typebox0.StaticType<[], "Decode", {}, {}, TDocument>;
+    driverParam: string;
+    enumValues: undefined;
+  }>, typebox0.StaticType<[], "Decode", {}, {}, TDocument>>;
+  sqliteDateTime: {
+    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
+      name: "";
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
+      name: TName;
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+  };
+  sqliteBool: {
+    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
+      name: "";
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: boolean;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
+      name: TName;
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: boolean;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+  };
+  sqliteDate: {
+    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
+      name: "";
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
+    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
+      name: TName;
+      dataType: "custom";
+      columnType: "SQLiteCustomColumn";
+      data: string;
+      driverParam: number;
+      enumValues: undefined;
+    }>;
   };
-  actions?: {
-    onUpdate?: UpdateDeleteAction;
-    onDelete?: UpdateDeleteAction;
+}
+type SchemaToSqliteBuilder<T extends TObject> = { [key in keyof T["properties"]]: SQLiteColumnBuilderBase };
+//#endregion
+//#region ../../src/orm/providers/drivers/NodeSqliteProvider.d.ts
+/**
+ * Configuration options for the Node.js SQLite database provider.
+ */
+declare const nodeSqliteOptions: alepha26.Atom<alepha26.TObject<{
+  path: alepha26.TOptional<alepha26.TString>;
+}>, "alepha.postgres.node-sqlite.options">;
+type NodeSqliteProviderOptions = Static<typeof nodeSqliteOptions.schema>;
+declare module "alepha" {
+  interface State {
+    [nodeSqliteOptions.key]: NodeSqliteProviderOptions;
+  }
+}
+/**
+ * Add a fake support for SQLite in Node.js based on Postgres interfaces.
+ *
+ * This is NOT a real SQLite provider, it's a workaround to use SQLite with Drizzle ORM.
+ * This is NOT recommended for production use.
+ */
+declare class NodeSqliteProvider 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: DatabaseSync;
+  get name(): string;
+  readonly dialect = "sqlite";
+  get url(): string;
+  execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
+  readonly db: PgDatabase<any>;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 //#endregion
 //#region ../../src/orm/errors/DbError.d.ts
@@ -996,247 +1377,62 @@ declare class DatabaseTypeProvider {
   /**
    * 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.
- */
-declare const $sequence: {
-  (options?: SequencePrimitiveOptions): SequencePrimitive;
-  [KIND]: typeof SequencePrimitive;
-};
-interface SequencePrimitiveOptions extends PgSequenceOptions {
-  /**
-   * The name of the sequence. If not provided, the property key will be used.
-   */
-  name?: string;
-  provider?: DatabaseProvider;
-}
-declare class SequencePrimitive extends Primitive<SequencePrimitiveOptions> {
-  readonly provider: DatabaseProvider;
-  onInit(): void;
-  get name(): string;
-  next(): Promise<number>;
-  current(): Promise<number>;
-  protected $provider(): DatabaseProvider;
-}
-//#endregion
-//#region ../../src/orm/services/ModelBuilder.d.ts
-/**
- * Database-specific table configuration functions
- */
-interface TableConfigBuilders<TConfig> {
-  index: (name: string) => {
-    on: (...columns: any[]) => TConfig;
-  };
-  uniqueIndex: (name: string) => {
-    on: (...columns: any[]) => TConfig;
-  };
-  unique: (name: string) => {
-    on: (...columns: any[]) => TConfig;
-  };
-  check: (name: string, sql: SQL) => TConfig;
-  foreignKey: (config: {
-    name: string;
-    columns: any[];
-    foreignColumns: any[];
-  }) => TConfig;
-}
-/**
- * Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
- * into drizzle models (tables, enums, sequences, etc...).
- */
-declare abstract class ModelBuilder {
-  /**
-   * Build a table from an entity primitive.
-   */
-  abstract buildTable(entity: EntityPrimitive, options: {
-    tables: Map<string, unknown>;
-    enums: Map<string, unknown>;
-    schema: string;
-  }): void;
-  /**
-   * Build a sequence from a sequence primitive.
-   */
-  abstract buildSequence(sequence: SequencePrimitive, options: {
-    sequences: Map<string, unknown>;
-    schema: string;
-  }): void;
-  /**
-   * Convert camelCase to snake_case for column names.
-   */
-  protected toColumnName(str: string): string;
-  /**
-   * Build the table configuration function for any database.
-   * This includes indexes, foreign keys, constraints, and custom config.
-   *
-   * @param entity - The entity primitive
-   * @param builders - Database-specific builder functions
-   * @param tableResolver - Function to resolve entity references to table columns
-   * @param customConfigHandler - Optional handler for custom config
-   */
-  protected buildTableConfig<TConfig, TSelf>(entity: EntityPrimitive, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
-}
-//#endregion
-//#region ../../src/orm/providers/DrizzleKitProvider.d.ts
-declare class DrizzleKitProvider {
-  protected readonly log: alepha_logger4.Logger;
-  protected readonly alepha: Alepha;
-  /**
-   * Synchronize database with current schema definitions.
-   *
-   * In development mode, it will generate and execute migrations based on the current state.
-   * In testing mode, it will generate migrations from scratch without applying them.
-   *
-   * Does nothing in production mode, you must handle migrations manually.
-   */
-  synchronize(provider: DatabaseProvider): Promise<void>;
-  /**
-   * Mostly used for testing purposes. You can generate SQL migration statements without executing them.
-   */
-  generateMigration(provider: DatabaseProvider, prevSnapshot?: any): Promise<{
-    statements: string[];
-    models: Record<string, unknown>;
-    snapshot?: any;
-  }>;
-  /**
-   * Load all tables, enums, sequences, etc. from the provider's repositories.
-   */
-  getModels(provider: DatabaseProvider): Record<string, unknown>;
-  /**
-   * Load the migration snapshot from the database.
-   */
-  protected loadDevMigrations(provider: DatabaseProvider): Promise<DevMigrations | undefined>;
-  protected saveDevMigrations(provider: DatabaseProvider, curr: Record<string, any>, devMigrations?: DevMigrations): Promise<void>;
-  protected executeStatements(statements: string[], provider: DatabaseProvider, catchErrors?: boolean): Promise<void>;
-  protected createSchemaIfNotExists(provider: DatabaseProvider, schemaName: string): Promise<void>;
-  /**
-   * Try to load the official Drizzle Kit API.
-   * If not available, fallback to the local kit import.
-   */
-  importDrizzleKit(): typeof DrizzleKit;
-}
-declare const devMigrationsSchema: alepha34.TObject<{
-  id: alepha34.TNumber;
-  name: alepha34.TString;
-  snapshot: alepha34.TString;
-  created_at: alepha34.TString;
-}>;
-type DevMigrations = Static<typeof devMigrationsSchema>;
-//#endregion
-//#region ../../src/orm/providers/drivers/DatabaseProvider.d.ts
-type SQLLike = SQLWrapper | string;
-declare abstract class DatabaseProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: alepha_logger4.Logger;
-  protected abstract readonly builder: ModelBuilder;
-  protected abstract readonly kit: DrizzleKitProvider;
-  abstract readonly db: PgDatabase<any>;
-  abstract readonly dialect: "postgresql" | "sqlite";
-  abstract readonly url: string;
-  readonly enums: Map<string, unknown>;
-  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;
-  registerSequence(sequence: SequencePrimitive): void;
-  abstract execute(statement: SQLLike): Promise<Record<string, unknown>[]>;
-  run<T extends TObject>(statement: SQLLike, schema: T): Promise<Array<Static<T>>>;
-  /**
-   * Get migrations folder path - can be overridden
-   */
-  protected getMigrationsFolder(): string;
-  /**
-   * Base migration orchestration - handles environment logic
-   */
-  migrate(): Promise<void>;
-  /**
-   * Production: run migrations from folder
-   */
-  protected runProductionMigration(migrationsFolder: string): Promise<void>;
-  /**
-   * Test: always synchronize
-   */
-  protected runTestMigration(): Promise<void>;
-  /**
-   * Development: default to synchronize (can be overridden)
+   * The column is nullable - NULL means not deleted, timestamp means deleted.
    */
-  protected runDevelopmentMigration(migrationsFolder: string): Promise<void>;
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<alepha26.TOptional<TString>, typeof PG_DELETED_AT>;
   /**
-   * Common synchronization with error handling
+   * 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" });
+   * ```
    */
-  protected synchronizeSchema(): Promise<void>;
+  readonly enum: <T extends string[]>(values: [...T], pgEnumOptions?: PgEnumOptions, typeOptions?: TStringOptions) => PgAttr<TUnsafe<T[number]>, typeof PG_ENUM>;
   /**
-   * Provider-specific migration execution
-   * MUST be implemented by each provider
+   * Creates a reference to another table or schema. Basically a foreign key.
    */
-  protected abstract executeMigrations(migrationsFolder: string): Promise<void>;
+  readonly ref: <T extends TSchema>(type: T, ref: () => any, actions?: {
+    onUpdate?: UpdateDeleteAction$1;
+    onDelete?: UpdateDeleteAction$1;
+  }) => PgAttr<T, PgRef>;
   /**
-   * 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`.
+   * Creates a page schema for a given object schema.
+   * It's used by {@link Repository#paginate} method.
    */
-  protected generateTestSchemaName(): string;
+  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<alepha26.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 //#endregion
 //#region ../../src/orm/services/QueryManager.d.ts
 declare class QueryManager {
@@ -1302,7 +1498,7 @@ declare class QueryManager {
   createPagination<T>(entities: T[], limit?: number, offset?: number, sort?: Array<{
     column: string;
     direction: "asc" | "desc";
-  }>): alepha34.Page<T>;
+  }>): alepha26.Page<T>;
 }
 interface PgJoin {
   table: string;
@@ -1487,7 +1683,7 @@ declare abstract class Repository<T extends TObject> {
   /**
    * Find an entity and update it.
    */
-  updateOne(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
+  updateOne(where: PgQueryWhereOrSQL<T>, data: WithSQL<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Save a given entity.
    *
@@ -1512,11 +1708,11 @@ declare abstract class Repository<T extends TObject> {
   /**
    * Find an entity by ID and update it.
    */
-  updateById(id: string | number, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
+  updateById(id: string | number, data: WithSQL<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Static<T>>;
   /**
    * Find many entities and update all of them.
    */
-  updateMany(where: PgQueryWhereOrSQL<T>, data: Partial<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Array<number | string>>;
+  updateMany(where: PgQueryWhereOrSQL<T>, data: WithSQL<Static<TObjectUpdate<T>>>, opts?: StatementOptions): Promise<Array<number | string>>;
   /**
    * Find many and delete all of them.
    * @returns Array of deleted entity IDs
@@ -1611,6 +1807,7 @@ interface StatementOptions {
    */
   now?: DateTime | string;
 }
+type WithSQL<T> = { [P in keyof T]?: T[P] | SQL };
 //#endregion
 //#region ../../src/orm/primitives/$repository.d.ts
 /**
@@ -1739,160 +1936,6 @@ interface TransactionPrimitiveOptions<T extends any[], R> {
 }
 type TransactionContext = PgTransaction<any, any, any>;
 //#endregion
-//#region ../../src/orm/services/SqliteModelBuilder.d.ts
-declare class SqliteModelBuilder extends ModelBuilder {
-  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 SQLite-specific config builder for the table.
-   */
-  protected getTableConfig(entity: EntityPrimitive, tables: Map<string, unknown>): ((self: BuildColumns<string, any, "sqlite">) => any) | undefined;
-  schemaToSqliteColumns: <T extends TObject>(tableName: string, schema: T, enums: Map<string, unknown>, tables: Map<string, unknown>) => SchemaToSqliteBuilder<T>;
-  mapFieldToSqliteColumn: (tableName: string, fieldName: string, value: TSchema, enums: Map<string, any>) => pg$1.SQLiteIntegerBuilderInitial<string> | pg$1.SQLiteNumericBuilderInitial<string> | pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: string;
-    enumValues: undefined;
-  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: number;
-    enumValues: undefined;
-  }> | pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: boolean;
-    driverParam: number;
-    enumValues: undefined;
-  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: {
-      [x: string]: unknown;
-      [x: number]: unknown;
-      [x: symbol]: unknown;
-    };
-    driverParam: string;
-    enumValues: undefined;
-  }>, {
-    [x: string]: unknown;
-    [x: number]: unknown;
-    [x: symbol]: unknown;
-  }> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: typebox1.StaticRecord<[], "Decode", {}, {}, string, TSchema>;
-    driverParam: string;
-    enumValues: undefined;
-  }>, typebox1.StaticRecord<[], "Decode", {}, {}, string, TSchema>> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: any;
-    driverParam: string;
-    enumValues: undefined;
-  }>, any> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: unknown[];
-    driverParam: string;
-    enumValues: undefined;
-  }>, unknown[]>;
-  mapStringToSqliteColumn: (key: string, value: TString) => pg$1.SQLiteTextBuilderInitial<string, [string, ...string[]], number | undefined> | drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: string;
-    enumValues: undefined;
-  }>, string> | pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: string;
-    driverParam: number;
-    enumValues: undefined;
-  }>;
-  sqliteJson: <TDocument extends TSchema>(name: string, document: TDocument) => drizzle_orm0.$Type<pg$1.SQLiteCustomColumnBuilder<{
-    name: string;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
-    driverParam: string;
-    enumValues: undefined;
-  }>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
-  sqliteDateTime: {
-    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
-      name: "";
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
-      name: TName;
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-  };
-  sqliteBool: {
-    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
-      name: "";
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: boolean;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
-      name: TName;
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: boolean;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-  };
-  sqliteDate: {
-    <TConfig extends Record<string, any>>(fieldConfig: TConfig): pg$1.SQLiteCustomColumnBuilder<{
-      name: "";
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-    <TName extends string>(dbName: TName, fieldConfig: unknown): pg$1.SQLiteCustomColumnBuilder<{
-      name: TName;
-      dataType: "custom";
-      columnType: "SQLiteCustomColumn";
-      data: string;
-      driverParam: number;
-      enumValues: undefined;
-    }>;
-  };
-}
-type SchemaToSqliteBuilder<T extends TObject> = { [key in keyof T["properties"]]: SQLiteColumnBuilderBase };
-//#endregion
 //#region ../../src/orm/providers/drivers/CloudflareD1Provider.d.ts
 /**
  * D1Database interface matching Cloudflare's D1 API.
@@ -1952,7 +1995,7 @@ declare class CloudflareD1Provider extends DatabaseProvider {
   get url(): string;
   get db(): PgDatabase<any>;
   execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
   /**
    * Override development migration to skip sync (not supported on D1).
@@ -1970,7 +2013,7 @@ declare class CloudflareD1Provider extends DatabaseProvider {
 declare class RepositoryProvider {
   protected readonly alepha: Alepha;
   protected readonly registry: Map<EntityPrimitive<any>, Service<Repository<any>>>;
-  getRepositories(provider?: DatabaseProvider): Repository<TObject<alepha34.TProperties>>[];
+  getRepositories(provider?: DatabaseProvider): Repository<TObject<alepha26.TProperties>>[];
   getRepository<T extends TObject>(entity: EntityPrimitive<T>): Repository<T>;
   createClassRepository<T extends TObject>(entity: EntityPrimitive<T>): Service<Repository<T>>;
 }
@@ -1983,10 +2026,10 @@ declare const schema: <TDocument extends TSchema>(name: string, document: TDocum
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
-  data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
+  data: typebox0.StaticType<[], "Decode", {}, {}, TDocument>;
   driverParam: string;
   enumValues: undefined;
-}>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
+}>, typebox0.StaticType<[], "Decode", {}, {}, TDocument>>;
 //#endregion
 //#region ../../src/orm/services/PostgresModelBuilder.d.ts
 declare class PostgresModelBuilder extends ModelBuilder {
@@ -2027,7 +2070,7 @@ declare class PostgresModelBuilder extends ModelBuilder {
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema$1>> {}
 }
-declare const envSchema$1: alepha34.TObject<{
+declare const envSchema$1: alepha26.TObject<{
   /**
    * Main configuration for database connection.
    * Accept a string in the format of a Postgres connection URL.
@@ -2035,11 +2078,11 @@ declare const envSchema$1: alepha34.TObject<{
    * or
    * Example: postgres://user:password@localhost:5432/database?sslmode=require
    */
-  DATABASE_URL: alepha34.TOptional<alepha34.TString>;
+  DATABASE_URL: alepha26.TOptional<alepha26.TString>;
   /**
    * In addition to the DATABASE_URL, you can specify the postgres schema name.
    */
-  POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
+  POSTGRES_SCHEMA: alepha26.TOptional<alepha26.TString>;
 }>;
 /**
  * Bun PostgreSQL provider using Drizzle ORM with Bun's native SQL client.
@@ -2089,8 +2132,8 @@ declare class BunPostgresProvider extends DatabaseProvider {
    */
   get db(): PgDatabase<any>;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
-  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected readonly onStop: alepha26.HookPrimitive<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrateLock: alepha_lock0.LockPrimitive<() => Promise<void>>;
@@ -2100,8 +2143,8 @@ declare class BunPostgresProvider extends DatabaseProvider {
 /**
  * Configuration options for the Bun SQLite database provider.
  */
-declare const bunSqliteOptions: alepha34.Atom<alepha34.TObject<{
-  path: alepha34.TOptional<alepha34.TString>;
+declare const bunSqliteOptions: alepha26.Atom<alepha26.TObject<{
+  path: alepha26.TOptional<alepha26.TString>;
 }>, "alepha.postgres.bun-sqlite.options">;
 type BunSqliteProviderOptions = Static<typeof bunSqliteOptions.schema>;
 declare module "alepha" {
@@ -2150,8 +2193,8 @@ declare class BunSqliteProvider extends DatabaseProvider {
   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 readonly onStart: alepha26.HookPrimitive<"start">;
+  protected readonly onStop: alepha26.HookPrimitive<"stop">;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
 }
 //#endregion
@@ -2159,7 +2202,7 @@ declare class BunSqliteProvider extends DatabaseProvider {
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
-declare const envSchema: alepha34.TObject<{
+declare const envSchema: alepha26.TObject<{
   /**
    * Main configuration for database connection.
    * Accept a string in the format of a Postgres connection URL.
@@ -2167,13 +2210,13 @@ declare const envSchema: alepha34.TObject<{
    * or
    * Example: postgres://user:password@localhost:5432/database?sslmode=require
    */
-  DATABASE_URL: alepha34.TOptional<alepha34.TString>;
+  DATABASE_URL: alepha26.TOptional<alepha26.TString>;
   /**
    * In addition to the DATABASE_URL, you can specify the postgres schema name.
    *
    * It will monkey patch drizzle tables.
    */
-  POSTGRES_SCHEMA: alepha34.TOptional<alepha34.TString>;
+  POSTGRES_SCHEMA: alepha26.TOptional<alepha26.TString>;
 }>;
 declare class NodePostgresProvider extends DatabaseProvider {
   static readonly SSL_MODES: readonly ["require", "allow", "prefer", "verify-full"];
@@ -2206,8 +2249,8 @@ declare class NodePostgresProvider extends DatabaseProvider {
    */
   get db(): PostgresJsDatabase;
   protected executeMigrations(migrationsFolder: string): Promise<void>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
-  protected readonly onStop: alepha34.HookPrimitive<"stop">;
+  protected readonly onStart: alepha26.HookPrimitive<"start">;
+  protected readonly onStop: alepha26.HookPrimitive<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrateLock: alepha_lock0.LockPrimitive<() => Promise<void>>;
@@ -2217,47 +2260,8 @@ declare class NodePostgresProvider extends DatabaseProvider {
   protected getClientOptions(): postgres.Options<any>;
   protected ssl(url: URL): "require" | "allow" | "prefer" | "verify-full" | undefined;
 }
-//#endregion
-//#region ../../src/orm/providers/drivers/NodeSqliteProvider.d.ts
-/**
- * Configuration options for the Node.js SQLite database provider.
- */
-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" {
-  interface State {
-    [nodeSqliteOptions.key]: NodeSqliteProviderOptions;
-  }
-}
-/**
- * Add a fake support for SQLite in Node.js based on Postgres interfaces.
- *
- * This is NOT a real SQLite provider, it's a workaround to use SQLite with Drizzle ORM.
- * This is NOT recommended for production use.
- */
-declare class NodeSqliteProvider 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: DatabaseSync;
-  get name(): string;
-  readonly dialect = "sqlite";
-  get url(): string;
-  execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
-  readonly db: PgDatabase<any>;
-  protected readonly onStart: alepha34.HookPrimitive<"start">;
-  protected executeMigrations(migrationsFolder: string): Promise<void>;
-}
 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 };
+  export { $entity, $repository, $sequence, $transaction, AlephaOrm, 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, SqliteProvider, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionPrimitiveOptions, buildQueryString, bunSqliteOptions, db, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 }
 declare module "alepha" {
   interface Hooks {
@@ -2325,58 +2329,31 @@ declare module "alepha" {
     };
   }
 }
+declare const SqliteProvider: typeof NodeSqliteProvider;
 /**
- * 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";
- *
- * const users = $entity({
- *   name: "users",
- *   schema: t.object({
- *     id: db.primaryKey(),
- *     name: t.text(),
- *     email: t.text(),
- *   }),
- * });
- *
- * class App {
- *   users = $repository(users);
- *
- *   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.
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | backend | epic | stable |
  *
- * It provides:
- * - A type-safe way to define entities and repositories. (via `$entity` and `$repository`)
- * - Custom query builders and filters.
- * - Built-in special columns like `createdAt`, `updatedAt`, `deletedAt`, `version`.
- * - Automatic JSONB support.
- * - Automatic synchronization of entities with the database schema (for testing and development).
- * - Fallback to raw SQL via Drizzle ORM `sql` function.
+ * Full-featured database abstraction built on Drizzle ORM with complete type safety.
  *
- * Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
+ * **Features:**
+ * - Define database entities with TypeBox schemas
+ * - Automatic timestamps, soft deletes, and versioning columns
+ * - Type-safe CRUD operations with filtering, pagination, sorting, and relationships
+ * - Database transaction support with automatic rollback
+ * - Auto-incrementing sequences for IDs
+ * - PostgreSQL support (Node.js, Bun, Cloudflare Workers via pglite)
+ * - SQLite support (Node.js, Bun, Cloudflare D1)
+ * - Automatic schema sync for development/testing
+ * - Drizzle Kit migrations for production
+ * - Type-safe filters: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `nin`, `like`, `between`
+ * - JSONB column support
+ * - Relationship joins
  *
- * @see {@link $entity}
- * @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: alepha34.Service<alepha34.Module>;
+declare const AlephaOrm: alepha26.Service<alepha26.Module>;
 //#endregion
-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 };
+export { $entity, $repository, $sequence, $transaction, AlephaOrm, 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, SqliteProvider, 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