@holo-js/db 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-import { PoolConfig, QueryResult } from 'pg';
-import { PoolOptions } from 'mysql2/promise';
-
 type LogicalColumnKind = 'id' | 'integer' | 'bigInteger' | 'string' | 'text' | 'boolean' | 'real' | 'decimal' | 'date' | 'datetime' | 'timestamp' | 'json' | 'blob' | 'uuid' | 'ulid' | 'snowflake' | 'vector' | 'enum';
 type ColumnDefaultKind = 'value' | 'now';
 type IdGenerationStrategy = 'autoIncrement' | 'uuid' | 'ulid' | 'snowflake';
@@ -149,6 +146,9 @@ type ResolvedColumn<TColumn extends ColumnInput> = TColumn extends {
 type BoundColumns<TColumns extends ColumnShapeInput$2> = {
     [K in keyof TColumns]: ResolvedColumn<TColumns[K]>;
 };
+interface DefineTableOptions {
+    indexes?: readonly TableIndexDefinition[];
+}
 type BoundTableDefinition<TName extends string, TColumns extends ColumnShapeInput$2> = TableDefinition<TName, BoundColumns<TColumns>> & BoundColumns<TColumns>;
 
 interface GeneratedSchemaTables {
@@ -551,84 +551,6 @@ interface DatabaseContextOptions {
     modelRegistry?: ModelRegistry;
 }
 
-interface PaginationMeta {
-    readonly total: number;
-    readonly perPage: number;
-    readonly pageName: string;
-    readonly currentPage: number;
-    readonly lastPage: number;
-    readonly from: number | null;
-    readonly to: number | null;
-    readonly hasMorePages: boolean;
-}
-interface PaginatorMethods<T> {
-    items(): readonly T[];
-    firstItem(): number | null;
-    lastItem(): number | null;
-    hasPages(): boolean;
-    hasMorePages(): boolean;
-    getPageName(): string;
-    toJSON(): {
-        data: readonly T[];
-        meta: PaginationMeta;
-    };
-}
-interface SimplePaginationMeta {
-    readonly perPage: number;
-    readonly pageName: string;
-    readonly currentPage: number;
-    readonly from: number | null;
-    readonly to: number | null;
-    readonly hasMorePages: boolean;
-}
-interface SimplePaginatorMethods<T> {
-    items(): readonly T[];
-    firstItem(): number | null;
-    lastItem(): number | null;
-    hasPages(): boolean;
-    hasMorePages(): boolean;
-    getPageName(): string;
-    toJSON(): {
-        data: readonly T[];
-        meta: SimplePaginationMeta;
-    };
-}
-interface PaginatedResult<T> extends PaginatorMethods<T> {
-    readonly data: readonly T[];
-    readonly meta: PaginationMeta;
-}
-interface SimplePaginatedResult<T> extends SimplePaginatorMethods<T> {
-    readonly data: readonly T[];
-    readonly meta: SimplePaginationMeta;
-}
-interface CursorPaginatorMethods<T> {
-    items(): readonly T[];
-    hasMorePages(): boolean;
-    getCursorName(): string;
-    nextCursorToken(): string | null;
-    previousCursorToken(): string | null;
-    toJSON(): {
-        data: readonly T[];
-        perPage: number;
-        cursorName: string;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    };
-}
-interface CursorPaginatedResult<T> extends CursorPaginatorMethods<T> {
-    readonly data: readonly T[];
-    readonly perPage: number;
-    readonly cursorName: string;
-    readonly nextCursor: string | null;
-    readonly prevCursor: string | null;
-}
-interface PaginationOptions {
-    readonly pageName?: string;
-}
-interface CursorPaginationOptions {
-    readonly cursorName?: string;
-}
-
 type QueryOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'in' | 'not in' | 'between' | 'not between' | 'like';
 type QueryDirection = 'asc' | 'desc';
 type QueryLockMode = 'update' | 'share';
@@ -834,6 +756,152 @@ declare function createInsertQueryPlan(source: QuerySource, values: readonly Rec
 declare function createUpdateQueryPlan(source: QuerySource, predicates: readonly QueryPredicateNode[], values: Readonly<Record<string, unknown>>): UpdateQueryPlan;
 declare function createDeleteQueryPlan(source: QuerySource, predicates: readonly QueryPredicateNode[]): DeleteQueryPlan;
 
+type QueryCacheTtlInput = number | Date;
+type QueryCacheFlexibleTtlInput = readonly [fresh: number, stale: number] | {
+    readonly fresh: number;
+    readonly stale: number;
+};
+interface QueryCacheConfig {
+    readonly ttl?: QueryCacheTtlInput;
+    readonly key?: string;
+    readonly driver?: string;
+    readonly flexible?: QueryCacheFlexibleTtlInput;
+    readonly invalidate?: readonly string[];
+}
+interface NormalizedQueryCacheConfig {
+    readonly ttl?: QueryCacheTtlInput;
+    readonly key?: string;
+    readonly driver?: string;
+    readonly flexible?: QueryCacheFlexibleTtlInput;
+    readonly invalidate?: readonly string[];
+}
+interface DatabaseQueryCacheBridge {
+    get<TValue>(key: string, options?: {
+        readonly driver?: string;
+    }): Promise<TValue | null>;
+    put<TValue>(key: string, value: TValue, options: {
+        readonly driver?: string;
+        readonly ttl?: QueryCacheTtlInput;
+        readonly dependencies?: readonly string[];
+    }): Promise<void>;
+    flexible<TValue>(key: string, ttl: QueryCacheFlexibleTtlInput, callback: () => TValue | Promise<TValue>, options?: {
+        readonly driver?: string;
+        readonly dependencies?: readonly string[];
+    }): Promise<TValue>;
+    forget(key: string, options?: {
+        readonly driver?: string;
+    }): Promise<boolean>;
+    invalidateDependencies(dependencies: readonly string[], options?: {
+        readonly driver?: string;
+    }): Promise<void>;
+}
+declare function getQueryCacheBridgeState(): {
+    bridge?: DatabaseQueryCacheBridge;
+};
+declare function configureDatabaseQueryCacheBridge(bridge?: DatabaseQueryCacheBridge): void;
+declare function getDatabaseQueryCacheBridge(): DatabaseQueryCacheBridge | undefined;
+declare function resetDatabaseQueryCacheBridge(): void;
+declare function normalizeQueryCacheConfig(input: QueryCacheTtlInput | QueryCacheConfig): NormalizedQueryCacheConfig;
+declare function createDeterministicQueryCacheKey(statement: CompiledStatement, connectionName: string): string;
+declare function resolveQueryCacheKey(statement: CompiledStatement, connectionName: string, config: NormalizedQueryCacheConfig): string;
+declare function createTableCacheDependency(connectionName: string, tableName: string): string;
+declare function normalizeQueryCacheDependencies(connectionName: string, dependencies: readonly string[]): readonly string[];
+declare function supportsAutomaticPredicateInvalidation(predicate: QueryPredicateNode): boolean;
+declare function supportsAutomaticQueryCacheInvalidation(plan: SelectQueryPlan): boolean;
+declare function inferAutomaticQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string): readonly string[] | undefined;
+declare function resolveQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string, explicit?: readonly string[]): readonly string[] | undefined;
+declare const queryCacheInternals: {
+    configureDatabaseQueryCacheBridge: typeof configureDatabaseQueryCacheBridge;
+    createDeterministicQueryCacheKey: typeof createDeterministicQueryCacheKey;
+    createTableCacheDependency: typeof createTableCacheDependency;
+    getQueryCacheBridgeState: typeof getQueryCacheBridgeState;
+    inferAutomaticQueryCacheDependencies: typeof inferAutomaticQueryCacheDependencies;
+    normalizeQueryCacheConfig: typeof normalizeQueryCacheConfig;
+    normalizeQueryCacheDependencies: typeof normalizeQueryCacheDependencies;
+    resolveQueryCacheDependencies: typeof resolveQueryCacheDependencies;
+    resolveQueryCacheKey: typeof resolveQueryCacheKey;
+    supportsAutomaticPredicateInvalidation: typeof supportsAutomaticPredicateInvalidation;
+    supportsAutomaticQueryCacheInvalidation: typeof supportsAutomaticQueryCacheInvalidation;
+};
+
+interface PaginationMeta {
+    readonly total: number;
+    readonly perPage: number;
+    readonly pageName: string;
+    readonly currentPage: number;
+    readonly lastPage: number;
+    readonly from: number | null;
+    readonly to: number | null;
+    readonly hasMorePages: boolean;
+}
+interface PaginatorMethods<T> {
+    items(): readonly T[];
+    firstItem(): number | null;
+    lastItem(): number | null;
+    hasPages(): boolean;
+    hasMorePages(): boolean;
+    getPageName(): string;
+    toJSON(): {
+        data: readonly T[];
+        meta: PaginationMeta;
+    };
+}
+interface SimplePaginationMeta {
+    readonly perPage: number;
+    readonly pageName: string;
+    readonly currentPage: number;
+    readonly from: number | null;
+    readonly to: number | null;
+    readonly hasMorePages: boolean;
+}
+interface SimplePaginatorMethods<T> {
+    items(): readonly T[];
+    firstItem(): number | null;
+    lastItem(): number | null;
+    hasPages(): boolean;
+    hasMorePages(): boolean;
+    getPageName(): string;
+    toJSON(): {
+        data: readonly T[];
+        meta: SimplePaginationMeta;
+    };
+}
+interface PaginatedResult<T> extends PaginatorMethods<T> {
+    readonly data: readonly T[];
+    readonly meta: PaginationMeta;
+}
+interface SimplePaginatedResult<T> extends SimplePaginatorMethods<T> {
+    readonly data: readonly T[];
+    readonly meta: SimplePaginationMeta;
+}
+interface CursorPaginatorMethods<T> {
+    items(): readonly T[];
+    hasMorePages(): boolean;
+    getCursorName(): string;
+    nextCursorToken(): string | null;
+    previousCursorToken(): string | null;
+    toJSON(): {
+        data: readonly T[];
+        perPage: number;
+        cursorName: string;
+        nextCursor: string | null;
+        prevCursor: string | null;
+    };
+}
+interface CursorPaginatedResult<T> extends CursorPaginatorMethods<T> {
+    readonly data: readonly T[];
+    readonly perPage: number;
+    readonly cursorName: string;
+    readonly nextCursor: string | null;
+    readonly prevCursor: string | null;
+}
+interface PaginationOptions {
+    readonly pageName?: string;
+}
+interface CursorPaginationOptions {
+    readonly cursorName?: string;
+}
+
 type SelectRow<TTableOrName extends string | TableDefinition> = TTableOrName extends TableDefinition ? InferSelect<TTableOrName> : Record<string, unknown>;
 type TableReference = string | TableDefinition;
 type BuilderCallback$2<TBuilder> = (query: TBuilder) => unknown;
@@ -849,9 +917,10 @@ type MergeSelections<TTableOrName extends TableReference, TCurrentRow extends Re
 type AggregateSelectionResult<TAlias extends string, TValue> = Record<TAlias, TValue>;
 declare class TableQueryBuilder<TTableOrName extends TableReference = string, TSelectedRow extends Record<string, unknown> = SelectRow<TTableOrName>> {
     private readonly connection;
+    private readonly queryCacheConfig?;
     private readonly source;
     private readonly plan;
-    constructor(table: TTableOrName, connection: DatabaseContext, plan?: SelectQueryPlan);
+    constructor(table: TTableOrName, connection: DatabaseContext, plan?: SelectQueryPlan, queryCacheConfig?: NormalizedQueryCacheConfig | undefined);
     getTableName(): string;
     getConnectionName(): string;
     getConnection(): DatabaseContext;
@@ -1014,6 +1083,7 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
         source?: string;
     };
     dump(): TableQueryBuilder<TTableOrName, TSelectedRow>;
+    cache(config: QueryCacheTtlInput | QueryCacheConfig): TableQueryBuilder<TTableOrName, TSelectedRow>;
     get<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow[]>;
     first<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow | undefined>;
     sole<TRow extends Record<string, unknown> = TSelectedRow>(): Promise<TRow>;
@@ -1049,6 +1119,7 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
     unsafeQuery<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: Omit<UnsafeStatement, 'source'>): Promise<DriverQueryResult<TRow>>;
     unsafeExecute(statement: Omit<UnsafeStatement, 'source'>): Promise<DriverExecutionResult>;
     private clone;
+    private invalidateSourceTableQueries;
     private getCompiler;
     private getUnpaginatedRows;
     private resolvePrimaryKeyColumn;
@@ -1057,11 +1128,7 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
     private whereMultiColumns;
     private whereFullTextWithBoolean;
     private whereVectorSimilarToWithBoolean;
-    private assertPositiveInteger;
-    private normalizePaginationParameterName;
     private prepareCursorPaginationQuery;
-    private encodeCursor;
-    private decodeCursor;
     private aggregateNumeric;
     private extractNumericValues;
     private normalizeUpdateValues;
@@ -1364,6 +1431,7 @@ type MorphModelTarget$1 = {
         morphClass?: string;
     };
 };
+type MorphRelationTypeInput = string | MorphModelTarget$1 | readonly (string | MorphModelTarget$1)[];
 type MorphTypeSelector$1 = string | MorphModelTarget$1 | MorphEntityTarget$1 | null;
 type EagerLoad = {
     relation: string;
@@ -1488,24 +1556,8 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
     orWhereDoesntHave(relation: ModelRelationPath<TRelations>, constraint?: RelationConstraint): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     whereRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     orWhereRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    whereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: string | {
-        definition?: {
-            morphClass?: string;
-        };
-    } | readonly (string | {
-        definition?: {
-            morphClass?: string;
-        };
-    })[], column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
-    orWhereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: string | {
-        definition?: {
-            morphClass?: string;
-        };
-    } | readonly (string | {
-        definition?: {
-            morphClass?: string;
-        };
-    })[], column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    whereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: MorphRelationTypeInput, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    orWhereMorphRelation<TRelationPath extends ModelRelationPath<TRelations>>(relation: TRelationPath, types: MorphRelationTypeInput, column: RelatedColumnNameForRelationPath<TRelations, TRelationPath>, operator: unknown, value?: unknown): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     whereBelongsTo<TRelated extends TableDefinition>(relatedEntity: Entity<TRelated>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     orWhereBelongsTo<TRelated extends TableDefinition>(relatedEntity: Entity<TRelated>, relationName?: ModelRelationPath<TRelations>): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     whereMorphedTo(relation: ModelRelationPath<TRelations>, target: MorphTypeSelector$1): ModelQueryBuilder<TTable, TRelations, TLoaded>;
@@ -1562,6 +1614,7 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
         source?: string;
     };
     dump(): ModelQueryBuilder<TTable, TRelations, TLoaded>;
+    cache(config: QueryCacheTtlInput | QueryCacheConfig): ModelQueryBuilder<TTable, TRelations, TLoaded>;
     get(): Promise<ModelCollection<TTable, TRelations> & Array<EntityWithLoaded<TTable, TRelations, TLoaded>>>;
     first(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded> | undefined>;
     sole(): Promise<EntityWithLoaded<TTable, TRelations, TLoaded>>;
@@ -1607,6 +1660,7 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
     private normalizeAggregateLoads;
     private normalizeMorphTypes;
     private applyMorphedToFilter;
+    private applyMorphRelationFilter;
     private normalizeMorphedToTarget;
     private isMorphEntityTarget;
     private getMorphTargetLabels;
@@ -1614,13 +1668,10 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
     private normalizeColumnAggregateLoads;
     private parseAggregateRelation;
     private resolveBelongsToRelation;
+    private applyBelongsToFilter;
     private resolveBelongsToRelationName;
     private extractNumericValues;
     private getUnpaginatedEntities;
-    private encodeCursor;
-    private decodeCursor;
-    private assertPositiveInteger;
-    private normalizePaginationParameterName;
     private prepareCursorPaginationQuery;
 }
 
@@ -2864,7 +2915,6 @@ declare class ConnectionManager {
 declare function createConnectionManager(options: ConnectionManagerOptions): ConnectionManager;
 
 declare class DatabaseFacade {
-    private manager?;
     configure(manager: ConnectionManager): void;
     reset(): void;
     getManager(): ConnectionManager;
@@ -2887,12 +2937,32 @@ interface ActiveConnectionScope {
     connection: DatabaseContext;
 }
 declare class AsyncConnectionContext {
-    private readonly storage;
     run<T>(scope: ActiveConnectionScope, callback: () => T): T;
     getActive(): ActiveConnectionScope | undefined;
 }
 declare const connectionAsyncContext: AsyncConnectionContext;
 
+declare abstract class LazyDriverAdapter implements DriverAdapter {
+    private adapter?;
+    private pending?;
+    protected connected: boolean;
+    protected abstract readonly driverLabel: string;
+    protected abstract createConcreteAdapter(): Promise<DriverAdapter>;
+    protected resolveAdapter(): Promise<DriverAdapter>;
+    initialize(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
+    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
+    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
+    execute(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
+    beginTransaction(options?: DatabaseOperationOptions): Promise<void>;
+    commit(options?: DatabaseOperationOptions): Promise<void>;
+    rollback(options?: DatabaseOperationOptions): Promise<void>;
+    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+}
 interface SQLiteStatementLike {
     all(...params: readonly unknown[]): Record<string, unknown>[];
     run(...params: readonly unknown[]): {
@@ -2910,33 +2980,19 @@ interface SQLiteAdapterOptions {
     database?: SQLiteDatabaseLike;
     createDatabase?: (filename: string) => SQLiteDatabaseLike;
 }
-declare class SQLiteAdapter implements DriverAdapter {
-    private database?;
-    private connected;
-    private readonly filename;
-    private readonly createDatabaseInstance;
+declare class SQLiteAdapter extends LazyDriverAdapter {
+    private readonly options;
+    protected readonly driverLabel = "SQLiteAdapter";
+    readonly filename: string;
     constructor(options?: SQLiteAdapterOptions);
-    initialize(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
-    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
-    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    createSavepoint(name: string): Promise<void>;
-    rollbackToSavepoint(name: string): Promise<void>;
-    releaseSavepoint(name: string): Promise<void>;
-    private getDatabase;
-    private normalizeSavepointName;
-    private invokeStatement;
-    private isBindingArityError;
+    protected createConcreteAdapter(): Promise<DriverAdapter>;
+    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
 }
 declare function createSQLiteAdapter(options?: SQLiteAdapterOptions): SQLiteAdapter;
-
 interface PostgresQueryableLike {
-    query(sql: string, bindings?: readonly unknown[]): Promise<QueryResult<Record<string, unknown>> | {
+    query(sql: string, bindings?: readonly unknown[]): Promise<{
         rows: Record<string, unknown>[];
         rowCount?: number | null;
     }>;
@@ -2949,45 +3005,40 @@ interface PostgresPoolLike extends PostgresQueryableLike {
     connect(): Promise<PostgresClientLike>;
     end(): Promise<void>;
 }
-interface PostgresAdapterOptions {
+interface PostgresConnectionConfig {
     connectionString?: string;
-    config?: PoolConfig;
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    ssl?: boolean | Record<string, unknown>;
+}
+interface PostgresAdapterOptions<TConfig extends PostgresConnectionConfig = PostgresConnectionConfig> {
+    connectionString?: string;
+    config?: TConfig;
     client?: PostgresClientLike;
     pool?: PostgresPoolLike;
-    createPool?: (config?: PoolConfig) => PostgresPoolLike;
-}
-declare class PostgresAdapter implements DriverAdapter {
-    private pool?;
-    private readonly directClient?;
-    private readonly createPoolInstance?;
-    private readonly config?;
-    private connected;
-    private transactionClient?;
-    private leasedTransactionClient;
-    private readonly transactionScope;
-    constructor(options?: PostgresAdapterOptions);
-    initialize(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
-    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
-    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
-    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    createSavepoint(name: string): Promise<void>;
-    rollbackToSavepoint(name: string): Promise<void>;
-    releaseSavepoint(name: string): Promise<void>;
-    private getQueryable;
-    private leaseTransactionClient;
-    private requireTransactionClient;
-    private releaseTransactionClient;
-    private releaseScopedTransaction;
-    private normalizeSavepointName;
-}
-declare function createPostgresAdapter(options?: PostgresAdapterOptions): PostgresAdapter;
-
+    createPool?: (config?: TConfig) => PostgresPoolLike;
+}
+declare class PostgresAdapter<TConfig extends PostgresConnectionConfig = PostgresConnectionConfig> extends LazyDriverAdapter {
+    private readonly options;
+    protected readonly driverLabel = "PostgresAdapter";
+    readonly config?: TConfig;
+    constructor(options?: PostgresAdapterOptions<TConfig>);
+    protected createConcreteAdapter(): Promise<DriverAdapter>;
+    releaseScopedTransaction(state: {
+        client: {
+            release?(): void;
+        };
+        leased: boolean;
+        released: boolean;
+    }): void;
+    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+}
+declare function createPostgresAdapter<TConfig extends PostgresConnectionConfig = PostgresConnectionConfig>(options?: PostgresAdapterOptions<TConfig>): PostgresAdapter<TConfig>;
 interface MySQLQueryableLike {
     query(sql: string, bindings?: readonly unknown[]): Promise<readonly [unknown, unknown]>;
 }
@@ -2999,44 +3050,40 @@ interface MySQLPoolLike extends MySQLQueryableLike {
     getConnection(): Promise<MySQLClientLike>;
     end(): Promise<void>;
 }
-interface MySQLAdapterOptions {
+interface MySQLConnectionConfig {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database?: string;
+    ssl?: unknown;
     uri?: string;
-    config?: PoolOptions;
+}
+interface MySQLAdapterOptions<TConfig extends MySQLConnectionConfig = MySQLConnectionConfig> {
+    uri?: string;
+    config?: TConfig;
     client?: MySQLClientLike;
     pool?: MySQLPoolLike;
-    createPool?: (config: PoolOptions) => MySQLPoolLike;
-}
-declare class MySQLAdapter implements DriverAdapter {
-    private pool?;
-    private readonly directClient?;
-    private readonly createPoolInstance?;
-    private readonly config;
-    private connected;
-    private transactionClient?;
-    private leasedTransactionClient;
-    private readonly transactionScope;
-    constructor(options?: MySQLAdapterOptions);
-    initialize(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
-    query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
-    introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[]): Promise<DriverQueryResult<TRow>>;
-    execute(sql: string, bindings?: readonly unknown[]): Promise<DriverExecutionResult>;
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    rollback(): Promise<void>;
-    createSavepoint(name: string): Promise<void>;
-    rollbackToSavepoint(name: string): Promise<void>;
-    releaseSavepoint(name: string): Promise<void>;
-    private getQueryable;
-    private leaseTransactionClient;
-    private requireTransactionClient;
-    private releaseTransactionClient;
-    private releaseScopedTransaction;
-    private normalizeSavepointName;
-}
-declare function createMySQLAdapter(options?: MySQLAdapterOptions): MySQLAdapter;
+    createPool?: (config: TConfig) => MySQLPoolLike;
+}
+declare class MySQLAdapter<TConfig extends MySQLConnectionConfig = MySQLConnectionConfig> extends LazyDriverAdapter {
+    private readonly options;
+    protected readonly driverLabel = "MySQLAdapter";
+    readonly config: TConfig;
+    constructor(options?: MySQLAdapterOptions<TConfig>);
+    protected createConcreteAdapter(): Promise<DriverAdapter>;
+    releaseScopedTransaction(state: {
+        client: {
+            release?(): void;
+        };
+        leased: boolean;
+        released: boolean;
+    }): void;
+    createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    rollbackToSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+    releaseSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
+}
+declare function createMySQLAdapter<TConfig extends MySQLConnectionConfig = MySQLConnectionConfig>(options?: MySQLAdapterOptions<TConfig>): MySQLAdapter<TConfig>;
 
 type SupportedDatabaseDriver = 'sqlite' | 'postgres' | 'mysql';
 interface RuntimeConnectionConfig {
@@ -3077,7 +3124,7 @@ type RuntimeAdapterConnectionConfig = {
 declare function isSupportedDatabaseDriver(value: string): value is SupportedDatabaseDriver;
 declare function parseDatabaseDriver(value: string | undefined, fallback: SupportedDatabaseDriver): SupportedDatabaseDriver;
 declare function createDialect(driver: SupportedDatabaseDriver): Dialect;
-declare function createAdapter(driver: SupportedDatabaseDriver, connection: string | RuntimeAdapterConnectionConfig): SQLiteAdapter | PostgresAdapter | MySQLAdapter;
+declare function createAdapter(driver: SupportedDatabaseDriver, connection: string | RuntimeAdapterConnectionConfig): SQLiteAdapter | PostgresAdapter<PostgresConnectionConfig> | MySQLAdapter<MySQLConnectionConfig>;
 declare function createRuntimeLogger(enabled: boolean): DatabaseLogger | undefined;
 declare function createRuntimeConnectionOptions(driver: SupportedDatabaseDriver, connection: string | RuntimeAdapterConnectionConfig, dbLogging: boolean, schemaName?: string, connectionName?: string): DatabaseContextOptions;
 declare function resolveRuntimeConnectionManagerOptions(config: RuntimeConfigInput): ConnectionManager;
@@ -3141,6 +3188,7 @@ declare class SQLQueryCompiler {
 }
 
 declare class SQLiteQueryCompiler extends SQLQueryCompiler {
+    protected compileLockClause(_lockMode: QueryLockMode): string;
     protected compileJsonPredicate(predicate: QueryJsonPredicate, bindings: unknown[]): string;
     protected compileJsonUpdateOperations(column: string, operations: readonly QueryJsonUpdateOperation[], bindings: unknown[]): string;
     protected compileDatePredicate(predicate: QueryDatePredicate, placeholder: string): string;
@@ -3750,6 +3798,8 @@ interface HoloProjectPaths {
     jobs: string;
     events: string;
     listeners: string;
+    authorizationPolicies: string;
+    authorizationAbilities: string;
 }
 interface HoloProjectConnectionConfig {
     driver?: SupportedDatabaseDriver;
@@ -3786,4 +3836,4 @@ interface NormalizedHoloProjectConfig {
 declare function normalizeHoloProjectConfig(config?: HoloProjectConfig): NormalizedHoloProjectConfig;
 declare function defineHoloProject<TConfig extends HoloProjectConfig>(config: TConfig): NormalizedHoloProjectConfig & TConfig;
 
-export { type AddColumnOperation, type AlterColumnOperation, type AnyColumnDefinition, AsyncConnectionContext, CapabilityError, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, DB, type DDLOperation, type DDLStatement, DEFAULT_CAPABILITIES, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_SECURITY_POLICY, DIALECT_ID_STRATEGY_MAP, DIALECT_LOGICAL_TYPE_MAP, DIALECT_VECTOR_SUPPORT, type DatabaseCapabilities, DatabaseContext, type DatabaseContextOptions, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DefineModelOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, Entity, type EntityWithLoaded, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, HasSnowflakes, HasUlids, HasUniqueIds, HasUuids, type HoloProjectConfig, type HoloProjectConnectionConfig, type HoloProjectDatabaseConfig, type HoloProjectPaths, HydrationError, type IdGenerationStrategy, type InferInsert, type InferSelect, type InferUpdate, type InsertQueryPlan, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedIndex, type LogicalColumnKind, type MigrateOptions, type MigrationContext, type MigrationDefinition, type MigrationErrorLog, type MigrationExecutionPolicy, MigrationService, type MigrationSquashPlan, type MigrationStartLog, type MigrationStatus, type MigrationSuccessLog, type MigrationTemplateKind, type MigrationTemplateOptions, type ModelAttributeKey, type ModelCollection, type ModelDefinition, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, ModelRepository, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, MySQLQueryCompiler, type MySQLQueryableLike, MySQLSchemaCompiler, type NormalizedHoloProjectConfig, type PaginatedResult, type PaginationMeta, PostgresAdapter, type PostgresAdapterOptions, type PostgresClientLike, type PostgresPoolLike, PostgresQueryCompiler, type PostgresQueryableLike, PostgresSchemaCompiler, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RelationDefinition, RelationError, type RelationMap, type RenameColumnOperation, type RenameIndexOperation, type RenameTableOperation, type ResolveEagerLoadPath, type ResolveEagerLoadUnion, type ResolveEagerLoads, type RollbackOptions, type RuntimeConfigInput, type RuntimeConnectionConfig, type RuntimeDatabaseConfig, type RuntimeHoloConfig, SQLQueryCompiler, SQLSchemaCompiler, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteDatabaseLike, SQLiteQueryCompiler, SQLiteSchemaCompiler, type SQLiteStatementLike, type SchemaColumnMismatch, type SchemaDefaultDialectName, type SchemaDialectName, type SchemaDiff, SchemaError, type SchemaForeignKeyMismatch, type SchemaIndexMismatch, SchemaRegistry, SchemaService, type SchemaSyncPlan, SecurityError, type SecurityPolicy, type SeedOptions, type SeederContext, type SeederDefinition, type SeederErrorLog, SeederService, type SeederStartLog, type SeederSuccessLog, type SelectQueryPlan, SerializationError, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, column, compileDialectDefaultLiteral, configureDB, connectionAsyncContext, createAdapter, createCapabilities, createConnectionManager, createCursorPaginator, createDatabase, createDeleteQueryPlan, createDialect, createFactoryService, createForeignKeyOperation, createIndexOperation, createInsertQueryPlan, createMigrationFileName, createMigrationService, createMigrationTimestamp, createModelCollection, createModelEventService, createModelRegistry, createMySQLAdapter, createPaginator, createPostgresAdapter, createQueryScheduler, createRuntimeConnectionOptions, createRuntimeLogger, createSQLiteAdapter, diffSchema as createSchemaDiff, createSchemaRegistry, createSchemaService, createSecurityPolicy, createSeederService, createSelectQueryPlan, createSimplePaginator, createTableOperation, createTableSource, createUpdateQueryPlan, defineFactory, defineGeneratedTable, defineHoloProject, defineMigration, defineModel, defineSeeder, diffSchema, dropColumnOperation, dropForeignKeyOperation, dropIndexOperation, dropTableOperation, encryptedCast, enumCast, generateMigrationTemplate, generateSnowflake, generateUlid, generateUuidV7, getGeneratedTableDefinition, getModelDefinition, hasMany, hasManyThrough, hasOne, hasOneThrough, inferMigrationTableName, inferMigrationTemplateKind, isSupportedDatabaseDriver, latestMorphOne, latestOfMany, listGeneratedTableDefinitions, morphMany, morphOfMany, morphOne, morphTo, morphToMany, morphedByMany, normalizeDialectReadValue, normalizeDialectWriteValue, normalizeHoloProjectConfig, normalizeMigrationSlug, ofMany, oldestMorphOne, oldestOfMany, parseDatabaseDriver, redactBindings, redactSql, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, resetDB, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };
+export { type AddColumnOperation, type AlterColumnOperation, type AnyColumnDefinition, AsyncConnectionContext, type BoundTableDefinition, CapabilityError, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, DB, type DDLOperation, type DDLStatement, DEFAULT_CAPABILITIES, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_SECURITY_POLICY, DIALECT_ID_STRATEGY_MAP, DIALECT_LOGICAL_TYPE_MAP, DIALECT_VECTOR_SUPPORT, type DatabaseCapabilities, DatabaseContext, type DatabaseContextOptions, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DatabaseQueryCacheBridge, type DefineModelOptions, type DefineTableOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, Entity, type EntityWithLoaded, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, HasSnowflakes, HasUlids, HasUniqueIds, HasUuids, type HoloProjectConfig, type HoloProjectConnectionConfig, type HoloProjectDatabaseConfig, type HoloProjectPaths, HydrationError, type IdGenerationStrategy, type InferInsert, type InferSelect, type InferUpdate, type InsertQueryPlan, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedIndex, type LogicalColumnKind, type MigrateOptions, type MigrationContext, type MigrationDefinition, type MigrationErrorLog, type MigrationExecutionPolicy, MigrationService, type MigrationSquashPlan, type MigrationStartLog, type MigrationStatus, type MigrationSuccessLog, type MigrationTemplateKind, type MigrationTemplateOptions, type ModelAttributeKey, type ModelCollection, type ModelDefinition, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, ModelRepository, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, MySQLQueryCompiler, type MySQLQueryableLike, MySQLSchemaCompiler, type NormalizedHoloProjectConfig, type PaginatedResult, type PaginationMeta, PostgresAdapter, type PostgresAdapterOptions, type PostgresClientLike, type PostgresPoolLike, PostgresQueryCompiler, type PostgresQueryableLike, PostgresSchemaCompiler, type QueryCacheConfig, type QueryCacheFlexibleTtlInput, type QueryCacheTtlInput, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RelationDefinition, RelationError, type RelationMap, type RenameColumnOperation, type RenameIndexOperation, type RenameTableOperation, type ResolveEagerLoadPath, type ResolveEagerLoadUnion, type ResolveEagerLoads, type RollbackOptions, type RuntimeConfigInput, type RuntimeConnectionConfig, type RuntimeDatabaseConfig, type RuntimeHoloConfig, SQLQueryCompiler, SQLSchemaCompiler, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteDatabaseLike, SQLiteQueryCompiler, SQLiteSchemaCompiler, type SQLiteStatementLike, type SchemaColumnMismatch, type SchemaDefaultDialectName, type SchemaDialectName, type SchemaDiff, SchemaError, type SchemaForeignKeyMismatch, type SchemaIndexMismatch, SchemaRegistry, SchemaService, type SchemaSyncPlan, SecurityError, type SecurityPolicy, type SeedOptions, type SeederContext, type SeederDefinition, type SeederErrorLog, SeederService, type SeederStartLog, type SeederSuccessLog, type SelectQueryPlan, SerializationError, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, column, compileDialectDefaultLiteral, configureDB, configureDatabaseQueryCacheBridge, connectionAsyncContext, createAdapter, createCapabilities, createConnectionManager, createCursorPaginator, createDatabase, createDeleteQueryPlan, createDialect, createFactoryService, createForeignKeyOperation, createIndexOperation, createInsertQueryPlan, createMigrationFileName, createMigrationService, createMigrationTimestamp, createModelCollection, createModelEventService, createModelRegistry, createMySQLAdapter, createPaginator, createPostgresAdapter, createQueryScheduler, createRuntimeConnectionOptions, createRuntimeLogger, createSQLiteAdapter, diffSchema as createSchemaDiff, createSchemaRegistry, createSchemaService, createSecurityPolicy, createSeederService, createSelectQueryPlan, createSimplePaginator, createTableOperation, createTableSource, createUpdateQueryPlan, defineFactory, defineGeneratedTable, defineHoloProject, defineMigration, defineModel, defineSeeder, diffSchema, dropColumnOperation, dropForeignKeyOperation, dropIndexOperation, dropTableOperation, encryptedCast, enumCast, generateMigrationTemplate, generateSnowflake, generateUlid, generateUuidV7, getDatabaseQueryCacheBridge, getGeneratedTableDefinition, getModelDefinition, hasMany, hasManyThrough, hasOne, hasOneThrough, inferMigrationTableName, inferMigrationTemplateKind, isSupportedDatabaseDriver, latestMorphOne, latestOfMany, listGeneratedTableDefinitions, morphMany, morphOfMany, morphOne, morphTo, morphToMany, morphedByMany, normalizeDialectReadValue, normalizeDialectWriteValue, normalizeHoloProjectConfig, normalizeMigrationSlug, ofMany, oldestMorphOne, oldestOfMany, parseDatabaseDriver, queryCacheInternals, redactBindings, redactSql, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, resetDB, resetDatabaseQueryCacheBridge, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };