metal-orm 1.0.15 → 1.0.16

package/dist/{select-Bkv8g8u_.d.ts → select-BKZrMRCQ.d.ts}

@@ -1023,6 +1023,12 @@ declare abstract class Dialect implements SelectCompiler, InsertCompiler, Update
     private readonly operandCompilers;
     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
@@ -1577,6 +1583,65 @@ interface SimpleQueryRunner {
  */
 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",
     Managed = "managed",
@@ -1605,63 +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;
@@ -1670,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;
@@ -1684,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: 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: 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 RawDefaultValue as $, type BelongsToManyRelation as A, type BinaryExpressionNode as B, type ColumnRef as C, Dialect as D, type ExpressionNode as E, type FunctionNode as F, type HasManyCollection as G, type HydrationPlan as H, type InExpressionNode as I, type JsonPathNode as J, type BelongsToReference as K, type LogicalExpressionNode as L, type ManyToManyCollection as M, type NullExpressionNode as N, type OperandNode as O, SelectQueryBuilder as P, type CheckConstraint as Q, type RelationMap as R, type SelectQueryNode as S, type TableRef as T, type UpdateQueryNode as U, type TableOptions as V, type WindowFunctionNode as W, type TableHooks as X, defineTable as Y, type ColumnType as Z, type ReferentialAction as _, type ColumnNode as a, type DefaultValue as a0, col as a1, RelationKinds as a2, type RelationType as a3, type CascadeMode as a4, type RelationDef as a5, hasMany as a6, hasOne as a7, belongsTo as a8, belongsToMany as a9, createExecutorFromQueryRunner as aA, type ColumnToTs as aa, type InferRow as ab, type HasOneReference as ac, createColumn as ad, createLiteral as ae, isOperandNode as af, isFunctionNode as ag, isCaseExpressionNode as ah, isWindowFunctionNode as ai, isExpressionSelectionNode as aj, type HydrationPivotPlan as ak, type HydrationRelationPlan as al, type HydrationMetadata as am, addDomainEvent as an, EntityStatus as ao, type QueryResult as ap, type RelationKey as aq, type RelationChange as ar, type HasDomainEvents as as, type OrmInterceptor as at, type DomainEventHandler as au, type OrmContextOptions as av, type QueryLogEntry as aw, type QueryLogger as ax, rowsToQueryResult as ay, type SimpleQueryRunner 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, OrmContext as v, type Entity as w, type HasManyRelation as x, type HasOneRelation as y, type BelongsToRelation 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "type": "module",
   "exports": {
     ".": {