alepha 0.11.5 → 0.11.6

package/postgres.d.ts

@@ -1,19 +1,21 @@
 import * as _alepha_core10 from "alepha";
-import { Alepha, AlephaError, Descriptor, DescriptorArgs, KIND, Page, Static, StaticEncode, TBigInt, TInteger, TNull, TNumber, TNumberOptions, TObject, TObjectOptions, TOptional, TPage, TSchema, TString, TStringOptions, TUnion, TUnsafe, pageSchema } from "alepha";
+import { Alepha, AlephaError, Descriptor, KIND, Page, Page as Page$1, PageQuery, PageQuery as PageQuery$1, 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 { BuildExtraConfigColumns, SQL, SQLWrapper, sql } 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, PgTransactionConfig, UpdateDeleteAction } 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 { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
+import * as pg$1 from "drizzle-orm/sqlite-core";
+import { SQLiteColumnBuilderBase } from "drizzle-orm/sqlite-core";
 import * as _alepha_retry0 from "alepha/retry";
-import * as typebox11 from "typebox";
-import { PgTransactionConfig as PgTransactionConfig$1 } from "drizzle-orm/pg-core/session";
+import { DatabaseSync } from "node:sqlite";
+import { PgTransactionConfig } from "drizzle-orm/pg-core/session";
+import * as typebox1 from "typebox";
 import * as DrizzleKit from "drizzle-kit/api";
-import { MigrationConfig } from "drizzle-orm/migrator";
 import * as dayjs0 from "dayjs";
 import { UpdateDeleteAction as UpdateDeleteAction$1 } from "drizzle-orm/pg-core/foreign-keys";
 export * from "drizzle-orm/pg-core";
@@ -260,8 +262,8 @@ interface PgRefOptions {
   };
 }
 //#endregion
-//#region src/errors/PgError.d.ts
-declare class PgError extends AlephaError {
+//#region src/errors/DbError.d.ts
+declare class DbError extends AlephaError {
   name: string;
   constructor(message: string, cause?: unknown);
 }
@@ -864,32 +866,102 @@ declare abstract class ModelBuilder {
   protected buildTableConfig<TConfig, TSelf>(entity: EntityDescriptor, builders: TableConfigBuilders<TConfig>, tableResolver?: (entityName: string) => any, customConfigHandler?: (config: any, self: TSelf) => TConfig[]): ((self: TSelf) => TConfig[]) | undefined;
 }
 //#endregion
+//#region src/providers/DrizzleKitProvider.d.ts
+declare class DrizzleKitProvider {
+  protected readonly log: _alepha_logger0.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.
+   */
+  protected importDrizzleKit(): typeof DrizzleKit;
+}
+declare const devMigrationsSchema: typebox1.TObject<{
+  id: typebox1.TNumber;
+  name: typebox1.TString;
+  snapshot: typebox1.TString;
+  created_at: typebox1.TString;
+}>;
+type DevMigrations = Static<typeof devMigrationsSchema>;
+//#endregion
 //#region src/providers/drivers/DatabaseProvider.d.ts
 type SQLLike = SQLWrapper | string;
 declare abstract class DatabaseProvider {
   protected readonly alepha: Alepha;
+  protected readonly log: _alepha_logger0.Logger;
   protected abstract readonly builder: ModelBuilder;
+  protected abstract readonly kit: DrizzleKitProvider;
   abstract readonly db: PgDatabase<any>;
-  abstract readonly dialect: "postgres" | "sqlite";
+  abstract readonly dialect: "postgresql" | "sqlite";
   readonly enums: Map<string, unknown>;
   readonly tables: Map<string, unknown>;
   readonly sequences: Map<string, unknown>;
-  table<T extends TObject>(entity: EntityDescriptor<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
+  get name(): string;
   get schema(): string;
+  table<T extends TObject>(entity: EntityDescriptor<T>): PgTableWithColumns<SchemaToTableConfig<T>>;
   registerEntity(entity: EntityDescriptor): void;
   registerSequence(sequence: SequenceDescriptor): 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
+   */
+  protected migrateDatabase(): 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>;
 }
 //#endregion
-//#region src/schemas/pageQuerySchema.d.ts
-declare const pageQuerySchema: typebox11.TObject<{
-  page: typebox11.TOptional<typebox11.TInteger>;
-  size: typebox11.TOptional<typebox11.TInteger>;
-  sort: typebox11.TOptional<typebox11.TString>;
-}>;
-type PageQuery = Static<typeof pageQuerySchema>;
-//#endregion
 //#region src/services/PgJsonQueryManager.d.ts
 /**
  * Manages JSONB query generation for nested object and array queries in PostgreSQL.
@@ -908,17 +980,24 @@ declare class PgJsonQueryManager {
    * @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>): SQL | undefined;
+  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>): SQL | undefined;
+  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;
   /**
@@ -941,14 +1020,23 @@ declare class PgJsonQueryManager {
    * @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.int() }))
+   * @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.
    */
   isArrayProperty(schema: TObject, path: string[]): boolean;
 }
 //#endregion
-//#region src/services/PgQueryManager.d.ts
-declare class PgQueryManager {
+//#region src/services/QueryManager.d.ts
+declare class QueryManager {
   protected readonly jsonQueryManager: PgJsonQueryManager;
   protected readonly alepha: Alepha;
   /**
@@ -958,11 +1046,12 @@ declare class PgQueryManager {
     schema: TObject;
     col: (key: string) => PgColumn;
     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): SQL | undefined;
+  protected buildJsonbQuery(column: PgColumn, nestedQuery: any, schema: TObject, columnName: string, dialect: "postgresql" | "sqlite"): SQL | undefined;
   /**
    * Check if an object has any filter operator properties.
    */
@@ -1045,91 +1134,15 @@ declare class PgRelationManager {
   buildSchemaWithJoins(baseSchema: TObject, joins: PgJoin[], parentPath?: string): TObject;
 }
 //#endregion
-//#region src/descriptors/$repository.d.ts
-/**
- * Creates a repository for database operations on a defined entity.
- *
- * This descriptor provides a comprehensive, type-safe interface for performing all
- * database operations on entities defined with $entity. It offers a rich set of
- * CRUD operations, advanced querying capabilities, pagination, transactions, and
- * built-in support for audit trails and soft deletes.
- */
-declare const $repository: {
-  <T extends TObject>(optionsOrEntity: EntityDescriptor<T> | EntityDescriptorOptions<T> | RepositoryDescriptorOptions<T>): RepositoryDescriptor<T>;
-  [KIND]: typeof RepositoryDescriptor;
-};
-interface RepositoryDescriptorOptions<T extends TObject> {
-  /**
-   * The entity table definition created with $entity.
-   *
-   * This table:
-   * - Must be created using the $entity descriptor
-   * - Defines the schema, indexes, and constraints for the repository
-   * - Provides type information for all repository operations
-   * - Must include exactly one primary key field
-   *
-   * The repository will automatically:
-   * - Generate typed CRUD operations based on the entity schema
-   * - Handle audit fields like createdAt, updatedAt, deletedAt
-   * - Support optimistic locking if version field is present
-   * - Provide soft delete functionality if deletedAt field exists
-   *
-   * **Entity Requirements**:
-   * - Must have been created with $entity descriptor
-   * - Schema must include a primary key field marked with `pg.primaryKey()`
-   * - Corresponding database table must exist (created via migrations)
-   *
-   * @example
-   * ```ts
-   * const User = $entity({
-   *   name: "users",
-   *   schema: t.object({
-   *     id: pg.primaryKey(t.uuid()),
-   *     email: t.text({ format: "email" }),
-   *     name: t.text()
-   *   })
-   * });
-   *
-   * const userRepository = $repository({ table: User });
-   * ```
-   */
-  entity: EntityDescriptor<T>;
-  /**
-   * Override the default PostgreSQL database provider.
-   *
-   * By default, the repository will use the injected PostgresProvider from the
-   * dependency injection container. Use this option to:
-   * - Connect to a different database
-   * - Use a specific connection pool
-   * - Implement custom database behavior
-   * - Support multi-tenant architectures with database per tenant
-   *
-   * **Common Use Cases**:
-   * - Multi-database applications
-   * - Read replicas for query optimization
-   * - Different databases for different entity types
-   * - Testing with separate test databases
-   *
-   * @default Uses injected PostgresProvider
-   *
-   * @example ReadOnlyPostgresProvider
-   * @example TenantSpecificPostgresProvider
-   * @example TestDatabaseProvider
-   */
-  provider?: DatabaseProvider;
-  name?: string;
-}
-declare class RepositoryDescriptor<T extends TObject = TObject> extends Descriptor<RepositoryDescriptorOptions<T>> {
+//#region src/services/Repository.d.ts
+declare abstract class Repository<T extends TObject> {
+  readonly entity: EntityDescriptor<T>;
+  readonly provider: DatabaseProvider;
   protected readonly relationManager: PgRelationManager;
-  protected readonly queryManager: PgQueryManager;
+  protected readonly queryManager: QueryManager;
   protected readonly dateTimeProvider: DateTimeProvider;
   protected readonly alepha: Alepha;
-  readonly provider: DatabaseProvider;
-  constructor(args: DescriptorArgs<RepositoryDescriptorOptions<T>>);
-  /**
-   * Get the entity descriptor associated with this repository.
-   */
-  get entity(): EntityDescriptor<T>;
+  constructor(entity: EntityDescriptor<T>, provider?: typeof DatabaseProvider);
   /**
    * Represents the primary key of the table.
    * - Key is the name of the primary key column.
@@ -1233,9 +1246,9 @@ declare class RepositoryDescriptor<T extends TObject = TObject> extends Descript
    *
    * > Pagination CAN also do a count query to get the total number of elements.
    */
-  paginate<R extends PgRelationMap<T>>(pagination?: PageQuery, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
+  paginate<R extends PgRelationMap<T>>(pagination?: PageQuery$1, query?: PgQueryRelations<T, R>, opts?: StatementOptions & {
     count?: boolean;
-  }): Promise<Page<PgStatic<T, R>>>;
+  }): Promise<Page$1<PgStatic<T, R>>>;
   /**
    * Find an entity by ID.
    *
@@ -1334,7 +1347,7 @@ declare class RepositoryDescriptor<T extends TObject = TObject> extends Descript
    */
   count(where?: PgQueryWhereOrSQL<T>, opts?: StatementOptions): Promise<number>;
   protected conflictMessagePattern: string;
-  protected handleError(error: unknown, message: string): PgError;
+  protected handleError(error: unknown, message: string): DbError;
   protected withDeletedAt(where: PgQueryWhereOrSQL<T>, opts?: {
     force?: boolean;
   }): PgQueryWhereOrSQL<T>;
@@ -1375,7 +1388,6 @@ declare class RepositoryDescriptor<T extends TObject = TObject> extends Descript
     col: PgColumn<drizzle_orm0.ColumnBaseConfig<drizzle_orm0.ColumnDataType, string>, {}, {}>;
     type: TSchema;
   };
-  protected $provider(): DatabaseProvider;
 }
 /**
  * The options for a statement.
@@ -1402,6 +1414,12 @@ interface StatementOptions {
   now?: DateTime;
 }
 //#endregion
+//#region src/descriptors/$repository.d.ts
+/**
+ * Get the repository for the given entity.
+ */
+declare const $repository: <T extends TObject>(entity: EntityDescriptor<T>) => Repository<T>;
+//#endregion
 //#region src/descriptors/$transaction.d.ts
 /**
  * Creates a transaction descriptor for database operations requiring atomicity and consistency.
@@ -1519,25 +1537,25 @@ interface TransactionDescriptorOptions<T extends any[], R> {
    * }
    * ```
    */
-  config?: PgTransactionConfig$1;
+  config?: PgTransactionConfig;
 }
 type TransactionContext = PgTransaction<any, any, any>;
 //#endregion
 //#region src/errors/PgConflictError.d.ts
-declare class PgConflictError extends PgError {
+declare class PgConflictError extends DbError {
   readonly name = "PgConflictError";
   readonly status = 409;
 }
 //#endregion
 //#region src/errors/PgEntityNotFoundError.d.ts
-declare class PgEntityNotFoundError extends PgError {
+declare class PgEntityNotFoundError extends DbError {
   readonly name = "EntityNotFoundError";
   readonly status = 404;
   constructor(entityName: string);
 }
 //#endregion
 //#region src/errors/PgMigrationError.d.ts
-declare class PgMigrationError extends PgError {
+declare class PgMigrationError extends DbError {
   readonly name = "PgMigrationError";
   constructor(cause?: unknown);
 }
@@ -1548,56 +1566,69 @@ declare class PgMigrationError extends PgError {
  * It's thrown by {@link RepositoryDescriptor#save} when the updated entity version does not match the one in the database.
  * This is used for optimistic concurrency control.
  */
-declare class PgVersionMismatchError extends PgError {
+declare class PgVersionMismatchError extends DbError {
   readonly name = "PgVersionMismatchError";
   constructor(table: string, id: any);
 }
 //#endregion
-//#region src/providers/DrizzleKitProvider.d.ts
-declare class DrizzleKitProvider {
-  protected readonly log: _alepha_logger0.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.
-   */
-  protected importDrizzleKit(): typeof DrizzleKit;
-}
-declare const devMigrationsSchema: typebox11.TObject<{
-  id: typebox11.TNumber;
-  name: typebox11.TString;
-  snapshot: typebox11.TString;
-  created_at: typebox11.TString;
-}>;
-type DevMigrations = Static<typeof devMigrationsSchema>;
+//#region src/helpers/parseQueryString.d.ts
+/**
+ * Parse a string query into a PgQueryWhere object.
+ *
+ * Supported syntax:
+ * - Simple equality: "name=John"
+ * - Operators: "age>18", "age>=18", "age<65", "age<=65", "status!=active"
+ * - LIKE patterns: "name~John" (like), "name~*John" (ilike)
+ * - NULL checks: "deletedAt=null", "email!=null"
+ * - IN arrays: "status=[pending,active]"
+ * - AND conditions: "name=John&age>18"
+ * - OR conditions: "name=John|email=john@example.com"
+ * - Nested AND/OR: "(name=John|name=Jane)&age>18"
+ * - JSONB nested: "profile.city=Paris"
+ *
+ * @example
+ * ```ts
+ * // Simple equality
+ * parseQueryString("name=John")
+ * // => { name: { eq: "John" } }
+ *
+ * // Multiple conditions
+ * parseQueryString("name=John&age>18")
+ * // => { and: [{ name: { eq: "John" } }, { age: { gt: 18 } }] }
+ *
+ * // OR conditions
+ * parseQueryString("status=active|status=pending")
+ * // => { or: [{ status: { eq: "active" } }, { status: { eq: "pending" } }] }
+ *
+ * // Complex nested
+ * parseQueryString("(name=John|name=Jane)&age>18&status!=archived")
+ * // => { and: [
+ * //      { or: [{ name: { eq: "John" } }, { name: { eq: "Jane" } }] },
+ * //      { age: { gt: 18 } },
+ * //      { status: { ne: "archived" } }
+ * //    ] }
+ *
+ * // JSONB nested query
+ * parseQueryString("profile.city=Paris&profile.age>25")
+ * // => { profile: { city: { eq: "Paris" }, age: { gt: 25 } } }
+ * ```
+ */
+declare function parseQueryString<T extends TObject>(query: string): PgQueryWhere<T>;
+/**
+ * Helper function to build query strings programmatically
+ *
+ * @example
+ * ```ts
+ * buildQueryString({
+ *   and: [
+ *     { name: "eq:John" },
+ *     { age: "gt:18" }
+ *   ]
+ * })
+ * // => "name=John&age>18"
+ * ```
+ */
+declare function buildQueryString(where: any): string;
 //#endregion
 //#region src/services/PostgresModelBuilder.d.ts
 declare class PostgresModelBuilder extends ModelBuilder {
@@ -1653,53 +1684,41 @@ declare const envSchema: _alepha_core10.TObject<{
    * It will monkey patch drizzle tables.
    */
   POSTGRES_SCHEMA: _alepha_core10.TOptional<_alepha_core10.TString>;
-  /**
-   * Synchronize the database schema with the models.
-   * It uses a custom implementation, it's not related to `drizzle-kit push` command.
-   * It will generate the migration script and save it to the DB.
-   *
-   * This is recommended for development and testing purposes only.
-   */
-  POSTGRES_SYNCHRONIZE: _alepha_core10.TOptional<_alepha_core10.TBoolean>;
 }>;
-interface NodePostgresProviderOptions {
-  migrations: MigrationConfig;
-  connection: postgres.Options<any>;
-}
 declare class NodePostgresProvider extends DatabaseProvider {
   static readonly SSL_MODES: readonly ["require", "allow", "prefer", "verify-full"];
-  readonly dialect = "postgres";
   protected readonly log: _alepha_logger0.Logger;
   protected readonly env: {
     DATABASE_URL?: string | undefined;
     POSTGRES_SCHEMA?: string | undefined;
-    POSTGRES_SYNCHRONIZE?: boolean | undefined;
   };
-  protected readonly alepha: Alepha;
   protected readonly kit: DrizzleKitProvider;
   protected readonly builder: PostgresModelBuilder;
   protected client?: postgres.Sql;
   protected pg?: PostgresJsDatabase;
-  readonly options: NodePostgresProviderOptions;
+  readonly dialect = "postgresql";
   /**
    * In testing mode, the schema name will be generated and deleted after the test.
    */
   protected schemaForTesting: string | undefined;
+  /**
+   * Execute a SQL statement.
+   */
   execute(statement: SQLLike): Promise<Array<Record<string, unknown>>>;
   /**
-   * Get Postgres schema.
+   * Get Postgres schema used by this provider.
    */
   get schema(): string;
+  /**
+   * Get the Drizzle Postgres database instance.
+   */
   get db(): PostgresJsDatabase;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
   protected readonly onStart: _alepha_core10.HookDescriptor<"start">;
   protected readonly onStop: _alepha_core10.HookDescriptor<"stop">;
   connect(): Promise<void>;
   close(): Promise<void>;
   protected migrate: _alepha_lock0.LockDescriptor<() => Promise<void>>;
-  /**
-   * Generate a minimal migration configuration.
-   */
-  protected getMigrationOptions(): MigrationConfig;
   /**
    * Map the DATABASE_URL to postgres client options.
    */
@@ -1713,6 +1732,198 @@ declare class NodePostgresProvider extends DatabaseProvider {
   protected generateTestSchemaName(): string;
 }
 //#endregion
+//#region src/services/SqliteModelBuilder.d.ts
+declare class SqliteModelBuilder extends ModelBuilder {
+  buildTable(entity: EntityDescriptor<any>, options: {
+    tables: Map<string, unknown>;
+    enums: Map<string, unknown>;
+    schema: string;
+  }): void;
+  buildSequence(sequence: SequenceDescriptor, options: {
+    sequences: Map<string, unknown>;
+    schema: string;
+  }): void;
+  /**
+   * Get SQLite-specific config builder for the table.
+   */
+  protected getTableConfig(entity: EntityDescriptor, 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: Record<string, unknown>;
+    driverParam: string;
+    enumValues: undefined;
+  }>, Record<string, unknown>> | 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/providers/drivers/NodeSqliteProvider.d.ts
+/**
+ * Configuration options for the Node.js SQLite database provider.
+ */
+declare const nodeSqliteOptions: _alepha_core10.Atom<typebox1.TObject<{
+  path: typebox1.TOptional<typebox1.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_logger0.Logger;
+  protected readonly env: {
+    DATABASE_URL?: string | undefined;
+  };
+  protected readonly builder: SqliteModelBuilder;
+  protected readonly options: Readonly<{
+    path?: string | undefined;
+  }>;
+  protected sqlite: DatabaseSync;
+  readonly dialect = "sqlite";
+  get path(): string;
+  execute(query: SQLLike): Promise<Array<Record<string, unknown>>>;
+  readonly db: PgDatabase<any>;
+  protected readonly onStart: _alepha_core10.HookDescriptor<"start">;
+  protected executeMigrations(migrationsFolder: string): Promise<void>;
+}
+//#endregion
 //#region src/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>;
@@ -1758,17 +1969,17 @@ declare class PostgresTypeProvider {
   /**
    * Creates a column Created At. So just a datetime column with a default value of the current timestamp.
    */
-  readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox11.TCodec<TString, dayjs0.Dayjs>, typeof PG_CREATED_AT>, typeof PG_DEFAULT>;
+  readonly createdAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox1.TCodec<TString, dayjs0.Dayjs>, 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<typebox11.TCodec<TString, dayjs0.Dayjs>, typeof PG_UPDATED_AT>, typeof PG_DEFAULT>;
+  readonly updatedAt: (options?: TStringOptions) => PgAttr<PgAttr<typebox1.TCodec<TString, dayjs0.Dayjs>, 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<typebox11.TOptional<typebox11.TCodec<TString, dayjs0.Dayjs>>, typeof PG_DELETED_AT>;
+  readonly deletedAt: (options?: TStringOptions) => PgAttr<typebox1.TOptional<typebox1.TCodec<TString, dayjs0.Dayjs>>, typeof PG_DELETED_AT>;
   /**
    * Creates a Postgres ENUM type.
    *
@@ -1796,11 +2007,19 @@ declare class PostgresTypeProvider {
 }
 declare const pg: PostgresTypeProvider;
 //#endregion
+//#region src/providers/RepositoryProvider.d.ts
+declare class RepositoryProvider {
+  protected readonly alepha: Alepha;
+  protected readonly registry: Map<EntityDescriptor<any>, Service<Repository<any>>>;
+  getRepositories(provider?: DatabaseProvider): Repository<TObject<typebox1.TProperties>>[];
+  createClassRepository<T extends TObject>(entity: EntityDescriptor<T>): Service<Repository<T>>;
+}
+//#endregion
 //#region src/schemas/legacyIdSchema.d.ts
 /**
  * @deprecated Use `pg.primaryKey()` instead.
  */
-declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox11.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
+declare const legacyIdSchema: PgAttr<PgAttr<PgAttr<typebox1.TInteger, typeof PG_PRIMARY_KEY>, typeof PG_SERIAL>, typeof PG_DEFAULT>;
 //#endregion
 //#region src/types/schema.d.ts
 /**
@@ -1810,12 +2029,78 @@ declare const schema: <TDocument extends TSchema>(name: string, document: TDocum
   name: string;
   dataType: "custom";
   columnType: "PgCustomColumn";
-  data: typebox11.StaticType<[], "Decode", {}, {}, TDocument>;
+  data: typebox1.StaticType<[], "Decode", {}, {}, TDocument>;
   driverParam: string;
   enumValues: undefined;
-}>, typebox11.StaticType<[], "Decode", {}, {}, TDocument>>;
+}>, typebox1.StaticType<[], "Decode", {}, {}, TDocument>>;
 //#endregion
 //#region src/index.d.ts
+declare module "alepha" {
+  interface Hooks {
+    /**
+     * Fires before creating an entity in the repository.
+     */
+    "repository:create:before": {
+      tableName: string;
+      data: any;
+    };
+    /**
+     * Fires after creating an entity in the repository.
+     */
+    "repository:create:after": {
+      tableName: string;
+      data: any;
+      entity: any;
+    };
+    /**
+     * Fires before updating entities in the repository.
+     */
+    "repository:update:before": {
+      tableName: string;
+      where: any;
+      data: any;
+    };
+    /**
+     * Fires after updating entities in the repository.
+     */
+    "repository:update:after": {
+      tableName: string;
+      where: any;
+      data: any;
+      entities: any[];
+    };
+    /**
+     * Fires before deleting entities from the repository.
+     */
+    "repository:delete:before": {
+      tableName: string;
+      where: any;
+    };
+    /**
+     * Fires after deleting entities from the repository.
+     */
+    "repository:delete:after": {
+      tableName: string;
+      where: any;
+      ids: Array<string | number>;
+    };
+    /**
+     * Fires before reading entities from the repository.
+     */
+    "repository:read:before": {
+      tableName: string;
+      query: any;
+    };
+    /**
+     * Fires after reading entities from the repository.
+     */
+    "repository:read:after": {
+      tableName: string;
+      query: any;
+      entities: any[];
+    };
+  }
+}
 /**
  * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
  *
@@ -1855,7 +2140,7 @@ declare const schema: <TDocument extends TSchema>(name: string, document: TDocum
  * @see {@link $transaction}
  * @module alepha.postgres
  */
-declare const AlephaPostgres: _alepha_core10.Service<_alepha_core10.Module<{}>>;
+declare const AlephaPostgres: _alepha_core10.Service<_alepha_core10.Module>;
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DatabaseProvider, DrizzleKitProvider, EntityColumn, EntityColumns, EntityDescriptor, EntityDescriptorOptions, FilterOperators, FromSchema, NodePostgresProvider, NodePostgresProviderOptions, 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, PageQuery, PgAttr, PgAttrField, PgConflictError, PgDefault, PgEntityNotFoundError, PgEnumOptions, PgError, PgIdentityOptions, PgMigrationError, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, PgVersionMismatchError, PostgresTypeProvider, RepositoryDescriptor, RepositoryDescriptorOptions, SQLLike, SchemaToTableConfig, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, type TPage, TransactionContext, TransactionDescriptorOptions, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, pageQuerySchema, pageSchema, pg, pgAttr, schema, sql, updateSchema };
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, DatabaseProvider, DbError, DrizzleKitProvider, EntityColumn, EntityColumns, EntityDescriptor, EntityDescriptorOptions, 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, PgConflictError, PgDefault, PgEntityNotFoundError, PgEnumOptions, PgIdentityOptions, PgMigrationError, PgPrimaryKey, PgQuery, PgQueryRelations, PgQueryWhere, PgQueryWhereOrSQL, PgRef, PgRefOptions, PgRelation, PgRelationMap, PgStatic, PgSymbolKeys, PgSymbols, PgVersionMismatchError, PostgresTypeProvider, Repository, RepositoryProvider, SQLLike, SchemaToTableConfig, SequenceDescriptor, SequenceDescriptorOptions, StatementOptions, TObjectInsert, TObjectUpdate, TransactionContext, TransactionDescriptorOptions, buildQueryString, drizzle_orm0 as drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.d.ts.map