metal-orm 1.0.14 → 1.0.16

package/dist/{select-CCp1oz9p.d.cts → select-BKZrMRCQ.d.cts}

@@ -154,6 +154,8 @@ declare const col: {
  * Types of relationships supported between tables
  */
 declare const RelationKinds: {
+    /** One-to-one relationship */
+    readonly HasOne: "HAS_ONE";
     /** One-to-many relationship */
     readonly HasMany: "HAS_MANY";
     /** Many-to-one relationship */
@@ -176,6 +178,16 @@ interface HasManyRelation<TTarget extends TableDef = TableDef> {
     localKey?: string;
     cascade?: CascadeMode;
 }
+/**
+ * One-to-one relationship definition
+ */
+interface HasOneRelation<TTarget extends TableDef = TableDef> {
+    type: typeof RelationKinds.HasOne;
+    target: TTarget;
+    foreignKey: string;
+    localKey?: string;
+    cascade?: CascadeMode;
+}
 /**
  * Many-to-one relationship definition
  */
@@ -204,7 +216,7 @@ interface BelongsToManyRelation<TTarget extends TableDef = TableDef> {
 /**
  * Union type representing any supported relationship definition
  */
-type RelationDef = HasManyRelation | BelongsToRelation | BelongsToManyRelation;
+type RelationDef = HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation;
 /**
  * Creates a one-to-many relationship definition
  * @param target - Target table of the relationship
@@ -218,6 +230,14 @@ type RelationDef = HasManyRelation | BelongsToRelation | BelongsToManyRelation;
  * ```
  */
 declare const hasMany: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasManyRelation<TTarget>;
+/**
+ * Creates a one-to-one relationship definition
+ * @param target - Target table of the relationship
+ * @param foreignKey - Foreign key column name on the child table
+ * @param localKey - Local key column name (optional)
+ * @returns HasOneRelation definition
+ */
+declare const hasOne: <TTarget extends TableDef>(target: TTarget, foreignKey: string, localKey?: string, cascade?: CascadeMode) => HasOneRelation<TTarget>;
 /**
  * Creates a many-to-one relationship definition
  * @param target - Target table of the relationship
@@ -338,7 +358,7 @@ type ColumnToTs<T extends ColumnDef> = T['type'] extends 'INT' | 'INTEGER' | 'in
 type InferRow<TTable extends TableDef> = {
     [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
 };
-type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & {
+type RelationResult$1<T extends RelationDef> = T extends HasManyRelation<infer TTarget> ? InferRow<TTarget>[] : T extends HasOneRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToRelation<infer TTarget> ? InferRow<TTarget> | null : T extends BelongsToManyRelation<infer TTarget> ? (InferRow<TTarget> & {
     _pivot?: any;
 })[] : never;
 /**
@@ -360,6 +380,11 @@ interface BelongsToReference<TParent> {
     get(): TParent | null;
     set(data: Partial<TParent> | TParent | null): TParent | null;
 }
+interface HasOneReference<TChild> {
+    load(): Promise<TChild | null>;
+    get(): TChild | null;
+    set(data: Partial<TChild> | TChild | null): TChild | null;
+}
 interface ManyToManyCollection<TTarget> {
     load(): Promise<TTarget[]>;
     getItems(): TTarget[];
@@ -368,7 +393,7 @@ interface ManyToManyCollection<TTarget> {
     syncByIds(ids: (number | string)[]): Promise<void>;
 }
 type Entity<TTable extends TableDef, TRow = InferRow<TTable>> = TRow & {
-    [K in keyof RelationMap<TTable>]: TTable['relations'][K] extends HasManyRelation<infer TTarget> ? HasManyCollection<Entity<TTarget>> : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget> ? ManyToManyCollection<Entity<TTarget>> : TTable['relations'][K] extends BelongsToRelation<infer TTarget> ? BelongsToReference<Entity<TTarget>> : never;
+    [K in keyof RelationMap<TTable>]: TTable['relations'][K] extends HasManyRelation<infer TTarget> ? HasManyCollection<Entity<TTarget>> : TTable['relations'][K] extends HasOneRelation<infer TTarget> ? HasOneReference<Entity<TTarget>> : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget> ? ManyToManyCollection<Entity<TTarget>> : TTable['relations'][K] extends BelongsToRelation<infer TTarget> ? BelongsToReference<Entity<TTarget>> : never;
 } & {
     $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
 };
@@ -448,6 +473,43 @@ declare const ORDER_DIRECTIONS: {
  * Type representing any supported order direction
  */
 type OrderDirection = (typeof ORDER_DIRECTIONS)[keyof typeof ORDER_DIRECTIONS];
+/**
+ * Supported database dialects
+ */
+declare const SUPPORTED_DIALECTS: {
+    /** MySQL database dialect */
+    readonly MYSQL: "mysql";
+    /** SQLite database dialect */
+    readonly SQLITE: "sqlite";
+    /** Microsoft SQL Server dialect */
+    readonly MSSQL: "mssql";
+    /** PostgreSQL database dialect */
+    readonly POSTGRES: "postgres";
+};
+/**
+ * Type representing any supported database dialect
+ */
+type DialectName = (typeof SUPPORTED_DIALECTS)[keyof typeof SUPPORTED_DIALECTS];
+
+/**
+ * Minimal column reference used by AST builders.
+ * Accepts any object with a name and optional table/alias fields
+ * (schema ColumnDef/TableDef remain structurally compatible).
+ */
+interface ColumnRef {
+    name: string;
+    table?: string;
+    alias?: string;
+}
+/**
+ * Minimal table reference used by AST builders.
+ * Keeps AST decoupled from full schema TableDef shape.
+ */
+interface TableRef {
+    name: string;
+    schema?: string;
+    alias?: string;
+}
 
 /**
  * AST node representing a literal value
@@ -476,8 +538,10 @@ interface FunctionNode {
     type: 'Function';
     /** Function name (e.g., COUNT, SUM) */
     name: string;
+    /** Optional canonical function key for dialect-aware rendering */
+    fn?: string;
     /** Function arguments */
-    args: (ColumnNode | LiteralNode | JsonPathNode)[];
+    args: OperandNode[];
     /** Optional alias for the function result */
     alias?: string;
 }
@@ -542,7 +606,7 @@ declare const isOperandNode: (node: any) => node is OperandNode;
 declare const isFunctionNode: (node: any) => node is FunctionNode;
 declare const isCaseExpressionNode: (node: any) => node is CaseExpressionNode;
 declare const isWindowFunctionNode: (node: any) => node is WindowFunctionNode;
-declare const isExpressionSelectionNode: (node: ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode) => node is FunctionNode | CaseExpressionNode | WindowFunctionNode;
+declare const isExpressionSelectionNode: (node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode) => node is FunctionNode | CaseExpressionNode | WindowFunctionNode;
 /**
  * AST node representing a binary expression (e.g., column = value)
  */
@@ -626,11 +690,11 @@ interface JoinNode {
     /** Type of join (INNER, LEFT, RIGHT, etc.) */
     kind: JoinKind;
     /** Table to join */
-    table: TableNode;
+    table: TableNode | FunctionTableNode;
     /** Join condition expression */
     condition: ExpressionNode;
-    /** Optional relation name for code generation */
-    relationName?: string;
+    /** Optional metadata for non-SQL concerns (e.g., relation name) */
+    meta?: Record<string, unknown>;
 }
 
 /**
@@ -645,6 +709,26 @@ interface TableNode {
     /** Optional table alias */
     alias?: string;
 }
+/**
+ * AST node representing a function used as a table source (table-valued function)
+ */
+interface FunctionTableNode {
+    type: 'FunctionTable';
+    /** Function name */
+    name: string;
+    /** Optional schema for the function (some dialects) */
+    schema?: string;
+    /** Function arguments as operand nodes */
+    args?: any[];
+    /** Optional alias for the function table */
+    alias?: string;
+    /** LATERAL flag */
+    lateral?: boolean;
+    /** WITH ORDINALITY flag */
+    withOrdinality?: boolean;
+    /** Optional column aliases */
+    columnAliases?: string[];
+}
 /**
  * AST node representing an ORDER BY clause
  */
@@ -655,58 +739,6 @@ interface OrderByNode {
     /** Order direction (ASC or DESC) */
     direction: OrderDirection;
 }
-/**
- * Plan describing pivot columns needed for hydration
- */
-interface HydrationPivotPlan {
-    table: string;
-    primaryKey: string;
-    aliasPrefix: string;
-    columns: string[];
-}
-/**
- * Plan for hydrating relationship data
- */
-interface HydrationRelationPlan {
-    /** Name of the relationship */
-    name: string;
-    /** Alias prefix for the relationship */
-    aliasPrefix: string;
-    /** Type of relationship */
-    type: RelationType;
-    /** Target table name */
-    targetTable: string;
-    /** Target table primary key */
-    targetPrimaryKey: string;
-    /** Foreign key column */
-    foreignKey: string;
-    /** Local key column */
-    localKey: string;
-    /** Columns to include */
-    columns: string[];
-    /** Optional pivot plan for many-to-many relationships */
-    pivot?: HydrationPivotPlan;
-}
-/**
- * Complete hydration plan for a query
- */
-interface HydrationPlan {
-    /** Root table name */
-    rootTable: string;
-    /** Root table primary key */
-    rootPrimaryKey: string;
-    /** Root table columns */
-    rootColumns: string[];
-    /** Relationship hydration plans */
-    relations: HydrationRelationPlan[];
-}
-/**
- * Query metadata including hydration information
- */
-interface QueryMetadata {
-    /** Optional hydration plan */
-    hydration?: HydrationPlan;
-}
 /**
  * AST node representing a Common Table Expression (CTE)
  */
@@ -742,8 +774,8 @@ interface SelectQueryNode {
     type: 'SelectQuery';
     /** Optional CTEs (WITH clauses) */
     ctes?: CommonTableExpressionNode[];
-    /** FROM clause table */
-    from: TableNode;
+    /** FROM clause table (either a Table or a FunctionTable) */
+    from: TableNode | FunctionTableNode;
     /** SELECT clause columns */
     columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
     /** JOIN clauses */
@@ -761,7 +793,7 @@ interface SelectQueryNode {
     /** Optional OFFSET clause */
     offset?: number;
     /** Optional query metadata */
-    meta?: QueryMetadata;
+    meta?: Record<string, unknown>;
     /** Optional DISTINCT clause */
     distinct?: ColumnNode[];
     /** Optional set operations chaining this query with others */
@@ -805,6 +837,72 @@ interface DeleteQueryNode {
     returning?: ColumnNode[];
 }
 
+/**
+ * Plan describing pivot columns needed for hydration
+ */
+interface HydrationPivotPlan {
+    table: string;
+    primaryKey: string;
+    aliasPrefix: string;
+    columns: string[];
+}
+/**
+ * Plan for hydrating relationship data
+ */
+interface HydrationRelationPlan {
+    /** Name of the relationship */
+    name: string;
+    /** Alias prefix for the relationship */
+    aliasPrefix: string;
+    /** Type of relationship */
+    type: RelationType;
+    /** Target table name */
+    targetTable: string;
+    /** Target table primary key */
+    targetPrimaryKey: string;
+    /** Foreign key column */
+    foreignKey: string;
+    /** Local key column */
+    localKey: string;
+    /** Columns to include */
+    columns: string[];
+    /** Optional pivot plan for many-to-many relationships */
+    pivot?: HydrationPivotPlan;
+}
+/**
+ * Complete hydration plan for a query
+ */
+interface HydrationPlan {
+    /** Root table name */
+    rootTable: string;
+    /** Root table primary key */
+    rootPrimaryKey: string;
+    /** Root table columns */
+    rootColumns: string[];
+    /** Relationship hydration plans */
+    relations: HydrationRelationPlan[];
+}
+/**
+ * Metadata bag for attaching hydration to query ASTs without coupling AST types.
+ */
+interface HydrationMetadata {
+    hydration?: HydrationPlan;
+    [key: string]: unknown;
+}
+
+interface FunctionRenderContext {
+    node: FunctionNode;
+    compiledArgs: string[];
+}
+type FunctionRenderer = (ctx: FunctionRenderContext) => string;
+interface FunctionStrategy {
+    /**
+     * Returns a renderer for a specific function name (e.g. "DATE_ADD").
+     * Returns undefined if this dialect doesn't support the function.
+     */
+    getRenderer(functionName: string): FunctionRenderer | undefined;
+}
+
 /**
  * Context for SQL compilation with parameter management
  */
@@ -839,6 +937,8 @@ interface DeleteCompiler {
  * Abstract base class for SQL dialect implementations
  */
 declare abstract class Dialect implements SelectCompiler, InsertCompiler, UpdateCompiler, DeleteCompiler {
+    /** Dialect identifier used for function rendering and formatting */
+    protected abstract readonly dialect: DialectName;
     /**
      * Compiles a SELECT query AST to SQL
      * @param ast - Query AST to compile
@@ -921,7 +1021,14 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     protected normalizeSelectAst(ast: SelectQueryNode): SelectQueryNode;
     private readonly expressionCompilers;
     private readonly operandCompilers;
-    protected constructor();
+    protected readonly functionStrategy: FunctionStrategy;
+    protected constructor(functionStrategy?: FunctionStrategy);
+    /**
+     * Creates a new Dialect instance (for testing purposes)
+     * @param functionStrategy - Optional function strategy
+     * @returns New Dialect instance
+     */
+    static create(functionStrategy?: FunctionStrategy): Dialect;
     /**
      * Registers an expression compiler for a specific node type
      * @param type - Expression node type
@@ -951,8 +1058,14 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     private registerDefaultExpressionCompilers;
     private registerDefaultOperandCompilers;
     protected compileJsonPath(node: JsonPathNode): string;
+    /**
+     * Compiles a function operand, using the dialect's function strategy.
+     */
+    protected compileFunctionOperand(fnNode: FunctionNode, ctx: CompilerContext): string;
 }
 
+type DialectKey = 'postgres' | 'mysql' | 'sqlite' | 'mssql' | (string & {});
+
 /**
  * Node types that can be used in query projections
  */
@@ -1452,6 +1565,82 @@ interface DbExecutor {
     commitTransaction?(): Promise<void>;
     rollbackTransaction?(): Promise<void>;
 }
+/**
+ * Convert an array of row objects into a QueryResult.
+ */
+declare function rowsToQueryResult(rows: Array<Record<string, unknown>>): QueryResult;
+/**
+ * Minimal contract that most SQL clients can implement.
+ */
+interface SimpleQueryRunner {
+    query(sql: string, params?: unknown[]): Promise<Array<Record<string, unknown>>>;
+    beginTransaction?(): Promise<void>;
+    commitTransaction?(): Promise<void>;
+    rollbackTransaction?(): Promise<void>;
+}
+/**
+ * Generic factory: turn any SimpleQueryRunner into a DbExecutor.
+ */
+declare function createExecutorFromQueryRunner(runner: SimpleQueryRunner): DbExecutor;
+
+type EntityConstructor = new (...args: any[]) => any;
+type EntityOrTableTarget = EntityConstructor | TableDef;
+type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
+
+/**
+ * Strategy interface for converting database names to TypeScript identifiers
+ */
+interface NamingStrategy {
+    /**
+     * Converts a table name to a TypeScript symbol name
+     * @param table - Table node, function table node, or name
+     * @returns Valid TypeScript identifier
+     */
+    tableToSymbol(table: TableNode | FunctionTableNode | string): string;
+    /**
+     * Converts a column reference to a property name
+     * @param column - Column node
+     * @returns Valid TypeScript property name
+     */
+    columnToProperty(column: ColumnNode): string;
+}
+
+interface QueryContext {
+    sql: string;
+    params: unknown[];
+}
+type QueryInterceptor = (ctx: QueryContext, next: () => Promise<QueryResult[]>) => Promise<QueryResult[]>;
+declare class InterceptorPipeline {
+    private interceptors;
+    use(interceptor: QueryInterceptor): void;
+    run(ctx: QueryContext, executor: DbExecutor): Promise<QueryResult[]>;
+}
+
+interface OrmOptions {
+    dialect: Dialect;
+    executorFactory: DbExecutorFactory;
+    interceptors?: InterceptorPipeline;
+    namingStrategy?: NamingStrategy;
+}
+interface DbExecutorFactory {
+    createExecutor(options?: {
+        tx?: ExternalTransaction;
+    }): DbExecutor;
+    createTransactionalExecutor(): DbExecutor;
+}
+interface ExternalTransaction {
+}
+declare class Orm {
+    readonly dialect: Dialect;
+    readonly interceptors: InterceptorPipeline;
+    readonly namingStrategy: NamingStrategy;
+    private readonly executorFactory;
+    constructor(opts: OrmOptions);
+    createSession(options?: {
+        tx?: ExternalTransaction;
+    }): OrmSession;
+    transaction<T>(fn: (session: OrmSession) => Promise<T>): Promise<T>;
+}
 
 declare enum EntityStatus {
     New = "new",
@@ -1481,61 +1670,184 @@ type RelationChange<T> = {
     kind: 'detach';
     entity: T;
 };
+interface RelationChangeEntry {
+    root: any;
+    relationKey: RelationKey;
+    rootTable: TableDef;
+    relationName: string;
+    relation: RelationDef;
+    change: RelationChange<any>;
+}
 interface HasDomainEvents {
     domainEvents?: any[];
 }
 
-type DomainEventHandler$1<Context> = (event: any, ctx: Context) => Promise<void> | void;
+declare class IdentityMap {
+    private readonly buckets;
+    get bucketsMap(): Map<string, Map<string, TrackedEntity>>;
+    getEntity(table: TableDef, pk: string | number): any | undefined;
+    register(tracked: TrackedEntity): void;
+    remove(tracked: TrackedEntity): void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    clear(): void;
+    private toIdentityKey;
+}
+
+declare class UnitOfWork {
+    private readonly dialect;
+    private readonly executor;
+    private readonly identityMap;
+    private readonly hookContext;
+    private readonly trackedEntities;
+    constructor(dialect: Dialect, executor: DbExecutor, identityMap: IdentityMap, hookContext: () => unknown);
+    get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
+    getTracked(): TrackedEntity[];
+    getEntity(table: TableDef, pk: string | number): any | undefined;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    findTracked(entity: any): TrackedEntity | undefined;
+    setEntity(table: TableDef, pk: string | number, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: string | number): void;
+    trackManaged(table: TableDef, pk: string | number, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    flush(): Promise<void>;
+    reset(): void;
+    private flushInsert;
+    private flushUpdate;
+    private flushDelete;
+    private runHook;
+    private computeChanges;
+    private extractColumns;
+    private executeCompiled;
+    private getReturningColumns;
+    private applyReturningResults;
+    private normalizeColumnName;
+    private registerIdentity;
+    private createSnapshot;
+    private getPrimaryKeyValue;
+}
+
+type DomainEventHandler<Context> = (event: any, ctx: Context) => Promise<void> | void;
+declare class DomainEventBus<Context> {
+    private readonly handlers;
+    constructor(initialHandlers?: Record<string, DomainEventHandler<Context>[]>);
+    register(name: string, handler: DomainEventHandler<Context>): void;
+    dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void>;
+    private getEventName;
+}
 declare const addDomainEvent: (entity: HasDomainEvents, event: any) => void;
 
+declare class RelationChangeProcessor {
+    private readonly unitOfWork;
+    private readonly dialect;
+    private readonly executor;
+    private readonly relationChanges;
+    constructor(unitOfWork: UnitOfWork, dialect: Dialect, executor: DbExecutor);
+    registerChange(entry: RelationChangeEntry): void;
+    reset(): void;
+    process(): Promise<void>;
+    private handleHasManyChange;
+    private handleHasOneChange;
+    private handleBelongsToChange;
+    private handleBelongsToManyChange;
+    private assignHasManyForeignKey;
+    private detachHasManyChild;
+    private assignHasOneForeignKey;
+    private detachHasOneChild;
+    private insertPivotRow;
+    private deletePivotRow;
+    private resolvePrimaryKeyValue;
+}
+
 interface QueryLogEntry {
     sql: string;
     params?: unknown[];
 }
 type QueryLogger = (entry: QueryLogEntry) => void;
+declare const createQueryLoggingExecutor: (executor: DbExecutor, logger?: QueryLogger) => DbExecutor;
 
-interface OrmInterceptor {
-    beforeFlush?(ctx: OrmContext): Promise<void> | void;
-    afterFlush?(ctx: OrmContext): Promise<void> | void;
+interface ExecutionContext {
+    dialect: Dialect;
+    executor: DbExecutor;
+    interceptors: InterceptorPipeline;
 }
-type DomainEventHandler = DomainEventHandler$1<OrmContext>;
-interface OrmContextOptions {
+
+interface EntityContext {
     dialect: Dialect;
     executor: DbExecutor;
-    interceptors?: OrmInterceptor[];
-    domainEventHandlers?: Record<string, DomainEventHandler[]>;
-    queryLogger?: QueryLogger;
+    getEntity(table: TableDef, pk: any): any;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
 }
-declare class OrmContext {
-    private readonly options;
-    private readonly identityMap;
-    private readonly executorWithLogging;
-    private readonly unitOfWork;
-    private readonly relationChanges;
+
+interface HydrationContext {
+    identityMap: IdentityMap;
+    unitOfWork: UnitOfWork;
+    domainEvents: DomainEventBus<any>;
+    relationChanges: RelationChangeProcessor;
+    entityContext: EntityContext;
+}
+
+interface OrmInterceptor {
+    beforeFlush?(ctx: EntityContext): Promise<void> | void;
+    afterFlush?(ctx: EntityContext): Promise<void> | void;
+}
+interface OrmSessionOptions {
+    orm: Orm;
+    executor: DbExecutor;
+    queryLogger?: QueryLogger;
+    interceptors?: OrmInterceptor[];
+    domainEventHandlers?: Record<string, DomainEventHandler<OrmSession>[]>;
+}
+declare class OrmSession implements EntityContext {
+    readonly orm: Orm;
+    readonly executor: DbExecutor;
+    readonly identityMap: IdentityMap;
+    readonly unitOfWork: UnitOfWork;
+    readonly domainEvents: DomainEventBus<OrmSession>;
+    readonly relationChanges: RelationChangeProcessor;
     private readonly interceptors;
-    private readonly domainEvents;
-    constructor(options: OrmContextOptions);
+    constructor(opts: OrmSessionOptions);
     get dialect(): Dialect;
-    get executor(): DbExecutor;
     get identityBuckets(): Map<string, Map<string, TrackedEntity>>;
     get tracked(): TrackedEntity[];
-    getEntity(table: TableDef, pk: string | number): any | undefined;
-    setEntity(table: TableDef, pk: string | number, entity: any): void;
-    trackNew(table: TableDef, entity: any, pk?: string | number): void;
-    trackManaged(table: TableDef, pk: string | number, entity: any): void;
+    getEntity(table: TableDef, pk: any): any | undefined;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
     markDirty(entity: any): void;
     markRemoved(entity: any): void;
-    registerRelationChange(root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>): void;
-    registerInterceptor(interceptor: OrmInterceptor): void;
-    registerDomainEventHandler(name: string, handler: DomainEventHandler): void;
-    saveChanges(): Promise<void>;
+    registerRelationChange: (root: any, relationKey: RelationKey, rootTable: TableDef, relationName: string, relation: RelationDef, change: RelationChange<any>) => void;
     getEntitiesForTable(table: TableDef): TrackedEntity[];
+    registerInterceptor(interceptor: OrmInterceptor): void;
+    registerDomainEventHandler(name: string, handler: DomainEventHandler<OrmSession>): void;
+    find<TTable extends TableDef>(entityClass: EntityConstructor, id: any): Promise<Entity<TTable> | null>;
+    findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable> | null>;
+    findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]>;
+    persist(entity: object): Promise<void>;
+    remove(entity: object): Promise<void>;
+    flush(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    getExecutionContext(): ExecutionContext;
+    getHydrationContext(): HydrationContext;
 }
 
+type SelectDialectInput = Dialect | DialectKey;
+
 /**
+
  * Main query builder class for constructing SQL SELECT queries
+
  * @typeParam T - Result type for projections (unused)
+
  * @typeParam TTable - Table definition being queried
+
  */
 declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     private readonly env;
@@ -1544,11 +1856,17 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     private readonly relationManager;
     private readonly lazyRelations;
     /**
+  
      * Creates a new SelectQueryBuilder instance
+  
      * @param table - Table definition to query
+  
      * @param state - Optional initial query state
+  
      * @param hydration - Optional hydration manager
+  
      * @param dependencies - Optional query builder dependencies
+  
      */
     constructor(table: TTable, state?: SelectQueryState, hydration?: HydrationManager, dependencies?: Partial<SelectQueryBuilderDependencies>, lazyRelations?: Set<string>);
     private clone;
@@ -1558,215 +1876,358 @@ declare class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     private applyJoin;
     private applySetOperation;
     /**
+  
      * Selects specific columns for the query
+  
      * @param columns - Record of column definitions, function nodes, case expressions, or window functions
+  
      * @returns New query builder instance with selected columns
+  
      */
     select(columns: Record<string, ColumnDef | FunctionNode | CaseExpressionNode | WindowFunctionNode>): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Selects raw column expressions
+  
      * @param cols - Column expressions as strings
+  
      * @returns New query builder instance with raw column selections
+  
      */
     selectRaw(...cols: string[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a Common Table Expression (CTE) to the query
+  
      * @param name - Name of the CTE
+  
      * @param query - Query builder or query node for the CTE
+  
      * @param columns - Optional column names for the CTE
+  
      * @returns New query builder instance with the CTE
+  
      */
     with(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a recursive Common Table Expression (CTE) to the query
+  
      * @param name - Name of the CTE
+  
      * @param query - Query builder or query node for the CTE
+  
      * @param columns - Optional column names for the CTE
+  
      * @returns New query builder instance with the recursive CTE
+  
      */
     withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Selects a subquery as a column
+  
      * @param alias - Alias for the subquery column
+  
      * @param sub - Query builder or query node for the subquery
+  
      * @returns New query builder instance with the subquery selection
+  
      */
     selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds an INNER JOIN to the query
+  
      * @param table - Table to join
+  
      * @param condition - Join condition expression
+  
      * @returns New query builder instance with the INNER JOIN
+  
      */
     innerJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a LEFT JOIN to the query
+  
      * @param table - Table to join
+  
      * @param condition - Join condition expression
+  
      * @returns New query builder instance with the LEFT JOIN
+  
      */
     leftJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a RIGHT JOIN to the query
+  
      * @param table - Table to join
+  
      * @param condition - Join condition expression
+  
      * @returns New query builder instance with the RIGHT JOIN
+  
      */
     rightJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Matches records based on a relationship
+  
      * @param relationName - Name of the relationship to match
+  
      * @param predicate - Optional predicate expression
+  
      * @returns New query builder instance with the relationship match
+  
      */
     match(relationName: string, predicate?: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Joins a related table
+  
      * @param relationName - Name of the relationship to join
+  
      * @param joinKind - Type of join (defaults to INNER)
+  
      * @param extraCondition - Optional additional join condition
+  
      * @returns New query builder instance with the relationship join
+  
      */
     joinRelation(relationName: string, joinKind?: JoinKind, extraCondition?: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Includes related data in the query results
+  
      * @param relationName - Name of the relationship to include
+  
      * @param options - Optional include options
+  
      * @returns New query builder instance with the relationship inclusion
+  
      */
     include(relationName: string, options?: RelationIncludeOptions): SelectQueryBuilder<T, TTable>;
     includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable>;
     getLazyRelations(): (keyof RelationMap<TTable>)[];
     getTable(): TTable;
-    execute(ctx: OrmContext): Promise<Entity<TTable>[]>;
+    execute(ctx: OrmSession): Promise<Entity<TTable>[]>;
+    executeWithContexts(execCtx: ExecutionContext, hydCtx: HydrationContext): Promise<Entity<TTable>[]>;
     /**
+  
      * Adds a WHERE condition to the query
+  
      * @param expr - Expression for the WHERE clause
+  
      * @returns New query builder instance with the WHERE condition
+  
      */
     where(expr: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a GROUP BY clause to the query
+  
      * @param col - Column definition or column node to group by
+  
      * @returns New query builder instance with the GROUP BY clause
+  
      */
     groupBy(col: ColumnDef | ColumnNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a HAVING condition to the query
+  
      * @param expr - Expression for the HAVING clause
+  
      * @returns New query builder instance with the HAVING condition
+  
      */
     having(expr: ExpressionNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds an ORDER BY clause to the query
+  
      * @param col - Column definition or column node to order by
+  
      * @param direction - Order direction (defaults to ASC)
+  
      * @returns New query builder instance with the ORDER BY clause
+  
      */
     orderBy(col: ColumnDef | ColumnNode, direction?: OrderDirection): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a DISTINCT clause to the query
+  
      * @param cols - Columns to make distinct
+  
      * @returns New query builder instance with the DISTINCT clause
+  
      */
     distinct(...cols: (ColumnDef | ColumnNode)[]): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a LIMIT clause to the query
+  
      * @param n - Maximum number of rows to return
+  
      * @returns New query builder instance with the LIMIT clause
+  
      */
     limit(n: number): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds an OFFSET clause to the query
+  
      * @param n - Number of rows to skip
+  
      * @returns New query builder instance with the OFFSET clause
+  
      */
     offset(n: number): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using UNION
+  
      * @param query - Query to union with
+  
      * @returns New query builder instance with the set operation
+  
      */
     union(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using UNION ALL
+  
      * @param query - Query to union with
+  
      * @returns New query builder instance with the set operation
+  
      */
     unionAll(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using INTERSECT
+  
      * @param query - Query to intersect with
+  
      * @returns New query builder instance with the set operation
+  
      */
     intersect(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Combines this query with another using EXCEPT
+  
      * @param query - Query to subtract
+  
      * @returns New query builder instance with the set operation
+  
      */
     except(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a WHERE EXISTS condition to the query
+  
      * @param subquery - Subquery to check for existence
+  
      * @returns New query builder instance with the WHERE EXISTS condition
+  
      */
     whereExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a WHERE NOT EXISTS condition to the query
+  
      * @param subquery - Subquery to check for non-existence
+  
      * @returns New query builder instance with the WHERE NOT EXISTS condition
+  
      */
     whereNotExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a WHERE EXISTS condition based on a relationship
+  
      * @param relationName - Name of the relationship to check
+  
      * @param callback - Optional callback to modify the relationship query
+  
      * @returns New query builder instance with the relationship existence check
+  
      */
     whereHas(relationName: string, callback?: <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, TChildTable>): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Adds a WHERE NOT EXISTS condition based on a relationship
+  
      * @param relationName - Name of the relationship to check
+  
      * @param callback - Optional callback to modify the relationship query
+  
      * @returns New query builder instance with the relationship non-existence check
+  
      */
     whereHasNot(relationName: string, callback?: <TChildTable extends TableDef>(qb: SelectQueryBuilder<any, TChildTable>) => SelectQueryBuilder<any, TChildTable>): SelectQueryBuilder<T, TTable>;
     /**
+  
      * Compiles the query to SQL for a specific dialect
+  
      * @param dialect - Database dialect to compile for
+  
      * @returns Compiled query with SQL and parameters
+  
      */
-    compile(dialect: Dialect): CompiledQuery;
+    compile(dialect: SelectDialectInput): CompiledQuery;
     /**
+  
      * Converts the query to SQL string for a specific dialect
+  
      * @param dialect - Database dialect to generate SQL for
+  
      * @returns SQL string representation of the query
+  
      */
-    toSql(dialect: Dialect): string;
+    toSql(dialect: SelectDialectInput): string;
     /**
+  
      * Gets the hydration plan for the query
+  
      * @returns Hydration plan or undefined if none exists
+  
      */
     getHydrationPlan(): HydrationPlan | undefined;
     /**
+  
      * Gets the Abstract Syntax Tree (AST) representation of the query
+  
      * @returns Query AST with hydration applied
+  
      */
     getAST(): SelectQueryNode;
 }
 /**
+
  * Creates a column node for use in expressions
+
  * @param table - Table name
+
  * @param name - Column name
+
  * @returns ColumnNode with the specified table and name
+
  */
 declare const createColumn: (table: string, name: string) => ColumnNode;
 /**
+
  * Creates a literal value node for use in expressions
+
  * @param val - Literal value (string or number)
+
  * @returns LiteralNode with the specified value
+
  */
 declare const createLiteral: (val: string | number) => LiteralNode;
 
-export { type RelationType as $, type CheckConstraint as A, type BinaryExpressionNode as B, type ColumnDef as C, type DeleteQueryNode as D, type ExpressionNode as E, type FunctionNode as F, type TableOptions as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type TableHooks as K, type LogicalExpressionNode as L, type ManyToManyCollection as M, type NullExpressionNode as N, type OperandNode as O, defineTable as P, type ColumnType as Q, type RelationMap as R, type SelectQueryNode as S, type TableDef as T, type UpdateQueryNode as U, type ReferentialAction as V, type WindowFunctionNode as W, type RawDefaultValue as X, type DefaultValue as Y, col as Z, RelationKinds as _, type ColumnNode as a, type CascadeMode as a0, type RelationDef as a1, hasMany as a2, belongsTo as a3, belongsToMany as a4, type ColumnToTs as a5, type InferRow as a6, createColumn as a7, createLiteral as a8, isOperandNode as a9, isFunctionNode as aa, isCaseExpressionNode as ab, isWindowFunctionNode as ac, isExpressionSelectionNode as ad, addDomainEvent as ae, EntityStatus as af, type QueryResult as ag, type RelationKey as ah, type RelationChange as ai, type HasDomainEvents as aj, type OrmInterceptor as ak, type DomainEventHandler as al, type OrmContextOptions as am, type QueryLogEntry as an, type QueryLogger as ao, type LiteralNode as b, type BetweenExpressionNode as c, type CaseExpressionNode as d, type ExistsExpressionNode as e, type OrderDirection as f, type ScalarSubqueryNode as g, type InsertQueryNode as h, type InsertCompiler as i, type CompiledQuery as j, type UpdateCompiler as k, type DeleteCompiler as l, Dialect as m, type CompilerContext as n, type ForeignKeyReference as o, type IndexColumn as p, type IndexDef as q, type DbExecutor as r, OrmContext as s, type Entity as t, type HasManyRelation as u, type BelongsToRelation as v, type BelongsToManyRelation as w, type HasManyCollection as x, type BelongsToReference as y, SelectQueryBuilder as z };
+export { type TableHooks as $, type BelongsToRelation as A, type BinaryExpressionNode as B, type ColumnRef as C, Dialect as D, type ExpressionNode as E, type FunctionNode as F, type BelongsToManyRelation as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type HasManyCollection as K, type LogicalExpressionNode as L, type BelongsToReference as M, type NullExpressionNode as N, type OperandNode as O, type ManyToManyCollection as P, OrmSession as Q, type RelationMap as R, type SelectQueryNode as S, type TableRef as T, type UpdateQueryNode as U, SelectQueryBuilder as V, type WindowFunctionNode as W, type ExecutionContext as X, type HydrationContext as Y, type CheckConstraint as Z, type TableOptions as _, type ColumnNode as a, defineTable as a0, type ColumnType as a1, type ReferentialAction as a2, type RawDefaultValue as a3, type DefaultValue as a4, col as a5, RelationKinds as a6, type RelationType as a7, type CascadeMode as a8, type RelationDef as a9, EntityStatus as aA, type TrackedEntity as aB, type RelationKey as aC, type RelationChange as aD, type RelationChangeEntry as aE, type HasDomainEvents as aF, type QueryLogEntry as aG, type QueryLogger as aH, createQueryLoggingExecutor as aI, type QueryResult as aJ, rowsToQueryResult as aK, type SimpleQueryRunner as aL, createExecutorFromQueryRunner as aM, type EntityOrTableTargetResolver as aN, type EntityConstructor as aO, hasMany as aa, hasOne as ab, belongsTo as ac, belongsToMany as ad, type ColumnToTs as ae, type InferRow as af, type HasOneReference as ag, createColumn as ah, createLiteral as ai, isOperandNode as aj, isFunctionNode as ak, isCaseExpressionNode as al, isWindowFunctionNode as am, isExpressionSelectionNode as an, type HydrationPivotPlan as ao, type HydrationRelationPlan as ap, type HydrationMetadata as aq, type OrmInterceptor as ar, type OrmSessionOptions as as, type OrmOptions as at, type DbExecutorFactory as au, type ExternalTransaction as av, Orm as aw, type DomainEventHandler as ax, DomainEventBus as ay, addDomainEvent as az, type LiteralNode as b, type BetweenExpressionNode as c, type CaseExpressionNode as d, type ExistsExpressionNode as e, type OrderDirection as f, type ScalarSubqueryNode as g, type ColumnDef as h, type TableDef as i, type InsertQueryNode as j, type InsertCompiler as k, type CompiledQuery as l, type DialectKey as m, type UpdateCompiler as n, type DeleteQueryNode as o, type DeleteCompiler as p, type CompilerContext as q, type ForeignKeyReference as r, type IndexColumn as s, type IndexDef as t, type DbExecutor as u, type NamingStrategy as v, type EntityContext as w, type Entity as x, type HasManyRelation as y, type HasOneRelation as z };