metal-orm 1.0.15 → 1.0.16

package/dist/index.js

@@ -542,7 +542,7 @@ var StandardFunctionStrategy = class {
 };
 
 // src/core/dialect/abstract.ts
-var Dialect = class {
+var Dialect = class _Dialect {
   /**
    * Compiles a SELECT query AST to SQL
    * @param ast - Query AST to compile
@@ -715,6 +715,35 @@ var Dialect = class {
     this.registerDefaultOperandCompilers();
     this.registerDefaultExpressionCompilers();
   }
+  /**
+   * Creates a new Dialect instance (for testing purposes)
+   * @param functionStrategy - Optional function strategy
+   * @returns New Dialect instance
+   */
+  static create(functionStrategy) {
+    class TestDialect extends _Dialect {
+      constructor() {
+        super(...arguments);
+        this.dialect = "sqlite";
+      }
+      quoteIdentifier(id) {
+        return `"${id}"`;
+      }
+      compileSelectAst() {
+        throw new Error("Not implemented");
+      }
+      compileInsertAst() {
+        throw new Error("Not implemented");
+      }
+      compileUpdateAst() {
+        throw new Error("Not implemented");
+      }
+      compileDeleteAst() {
+        throw new Error("Not implemented");
+      }
+    }
+    return new TestDialect(functionStrategy);
+  }
   /**
    * Registers an expression compiler for a specific node type
    * @param type - Expression node type
@@ -4107,31 +4136,43 @@ var flattenResults = (results) => {
   }
   return rows;
 };
-async function executeHydrated(ctx, qb) {
+var executeWithEntityContext = async (entityCtx, qb) => {
   const ast = qb.getAST();
-  const compiled = ctx.dialect.compileSelect(ast);
-  const executed = await ctx.executor.executeSql(compiled.sql, compiled.params);
+  const compiled = entityCtx.dialect.compileSelect(ast);
+  const executed = await entityCtx.executor.executeSql(compiled.sql, compiled.params);
   const rows = flattenResults(executed);
   if (ast.setOps && ast.setOps.length > 0) {
-    return rows.map(
-      (row) => createEntityProxy(ctx, qb.getTable(), row, qb.getLazyRelations())
-    );
+    return rows.map((row) => createEntityProxy(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
   }
   const hydrated = hydrateRows(rows, qb.getHydrationPlan());
-  return hydrated.map(
-    (row) => createEntityFromRow(ctx, qb.getTable(), row, qb.getLazyRelations())
-  );
+  return hydrated.map((row) => createEntityFromRow(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
+};
+async function executeHydrated(session, qb) {
+  return executeWithEntityContext(session, qb);
+}
+async function executeHydratedWithContexts(_execCtx, hydCtx, qb) {
+  const entityCtx = hydCtx.entityContext;
+  if (!entityCtx) {
+    throw new Error("Hydration context is missing an EntityContext");
+  }
+  return executeWithEntityContext(entityCtx, qb);
 }
 
 // src/query-builder/select.ts
 var SelectQueryBuilder = class _SelectQueryBuilder {
   /**
-   * 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
-   */
+  
+     * 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, state, hydration, dependencies, lazyRelations) {
     const deps = resolveSelectQueryBuilderDependencies(dependencies);
     this.env = { table, deps };
@@ -4168,112 +4209,168 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.applyAst(this.context, (service) => service.withSetOperation(operator, subAst));
   }
   /**
-   * 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
-   */
+  
+     * 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) {
     return this.clone(this.columnSelector.select(this.context, columns));
   }
   /**
-   * Selects raw column expressions
-   * @param cols - Column expressions as strings
-   * @returns New query builder instance with raw column selections
-   */
+  
+     * Selects raw column expressions
+  
+     * @param cols - Column expressions as strings
+  
+     * @returns New query builder instance with raw column selections
+  
+     */
   selectRaw(...cols) {
     return this.clone(this.columnSelector.selectRaw(this.context, cols));
   }
   /**
-   * 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
-   */
+  
+     * 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, query, columns) {
     const subAst = this.resolveQueryNode(query);
     const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, false));
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, query, columns) {
     const subAst = this.resolveQueryNode(query);
     const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, true));
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, sub) {
     const query = this.resolveQueryNode(sub);
     return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
   }
   /**
-   * 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
-   */
+  
+     * 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, condition) {
     const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.INNER);
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, condition) {
     const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.LEFT);
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, condition) {
     const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.RIGHT);
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, predicate) {
     const nextContext = this.relationManager.match(this.context, relationName, predicate);
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, joinKind = JOIN_KINDS.INNER, extraCondition) {
     const nextContext = this.relationManager.joinRelation(this.context, relationName, joinKind, extraCondition);
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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, options) {
     const nextContext = this.relationManager.include(this.context, relationName, options);
     return this.clone(nextContext);
@@ -4292,125 +4389,186 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   async execute(ctx) {
     return executeHydrated(ctx, this);
   }
+  async executeWithContexts(execCtx, hydCtx) {
+    return executeHydratedWithContexts(execCtx, hydCtx, this);
+  }
   /**
-   * Adds a WHERE condition to the query
-   * @param expr - Expression for the WHERE clause
-   * @returns New query builder instance with the WHERE condition
-   */
+  
+     * 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) {
     const nextContext = this.applyAst(this.context, (service) => service.withWhere(expr));
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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(col2) {
     const nextContext = this.applyAst(this.context, (service) => service.withGroupBy(col2));
     return this.clone(nextContext);
   }
   /**
-   * Adds a HAVING condition to the query
-   * @param expr - Expression for the HAVING clause
-   * @returns New query builder instance with the HAVING condition
-   */
+  
+     * 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) {
     const nextContext = this.applyAst(this.context, (service) => service.withHaving(expr));
     return this.clone(nextContext);
   }
   /**
-   * 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
-   */
+  
+     * 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(col2, direction = ORDER_DIRECTIONS.ASC) {
     const nextContext = this.applyAst(this.context, (service) => service.withOrderBy(col2, direction));
     return this.clone(nextContext);
   }
   /**
-   * Adds a DISTINCT clause to the query
-   * @param cols - Columns to make distinct
-   * @returns New query builder instance with the DISTINCT clause
-   */
+  
+     * Adds a DISTINCT clause to the query
+  
+     * @param cols - Columns to make distinct
+  
+     * @returns New query builder instance with the DISTINCT clause
+  
+     */
   distinct(...cols) {
     return this.clone(this.columnSelector.distinct(this.context, cols));
   }
   /**
-   * Adds a LIMIT clause to the query
-   * @param n - Maximum number of rows to return
-   * @returns New query builder instance with the LIMIT clause
-   */
+  
+     * 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) {
     const nextContext = this.applyAst(this.context, (service) => service.withLimit(n));
     return this.clone(nextContext);
   }
   /**
-   * Adds an OFFSET clause to the query
-   * @param n - Number of rows to skip
-   * @returns New query builder instance with the OFFSET clause
-   */
+  
+     * 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) {
     const nextContext = this.applyAst(this.context, (service) => service.withOffset(n));
     return this.clone(nextContext);
   }
   /**
-   * Combines this query with another using UNION
-   * @param query - Query to union with
-   * @returns New query builder instance with the set operation
-   */
+  
+     * Combines this query with another using UNION
+  
+     * @param query - Query to union with
+  
+     * @returns New query builder instance with the set operation
+  
+     */
   union(query) {
     return this.clone(this.applySetOperation("UNION", query));
   }
   /**
-   * Combines this query with another using UNION ALL
-   * @param query - Query to union with
-   * @returns New query builder instance with the set operation
-   */
+  
+     * 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) {
     return this.clone(this.applySetOperation("UNION ALL", query));
   }
   /**
-   * Combines this query with another using INTERSECT
-   * @param query - Query to intersect with
-   * @returns New query builder instance with the set operation
-   */
+  
+     * Combines this query with another using INTERSECT
+  
+     * @param query - Query to intersect with
+  
+     * @returns New query builder instance with the set operation
+  
+     */
   intersect(query) {
     return this.clone(this.applySetOperation("INTERSECT", query));
   }
   /**
-   * Combines this query with another using EXCEPT
-   * @param query - Query to subtract
-   * @returns New query builder instance with the set operation
-   */
+  
+     * Combines this query with another using EXCEPT
+  
+     * @param query - Query to subtract
+  
+     * @returns New query builder instance with the set operation
+  
+     */
   except(query) {
     return this.clone(this.applySetOperation("EXCEPT", query));
   }
   /**
-   * 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
-   */
+  
+     * 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) {
     const subAst = this.resolveQueryNode(subquery);
     return this.where(exists(subAst));
   }
   /**
-   * 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
-   */
+  
+     * 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) {
     const subAst = this.resolveQueryNode(subquery);
     return this.where(notExists(subAst));
   }
   /**
-   * 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
-   */
+  
+     * 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, callback) {
     const relation = this.env.table.relations[relationName];
     if (!relation) {
@@ -4425,11 +4583,16 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.where(exists(finalSubAst));
   }
   /**
-   * 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
-   */
+  
+     * 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, callback) {
     const relation = this.env.table.relations[relationName];
     if (!relation) {
@@ -4444,33 +4607,47 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.where(notExists(finalSubAst));
   }
   /**
-   * Compiles the query to SQL for a specific dialect
-   * @param dialect - Database dialect to compile for
-   * @returns Compiled query with SQL and parameters
-   */
+  
+     * 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) {
     const resolved = resolveDialectInput(dialect);
     return resolved.compileSelect(this.context.state.ast);
   }
   /**
-   * 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
-   */
+  
+     * 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) {
     return this.compile(dialect).sql;
   }
   /**
-   * Gets the hydration plan for the query
-   * @returns Hydration plan or undefined if none exists
-   */
+  
+     * Gets the hydration plan for the query
+  
+     * @returns Hydration plan or undefined if none exists
+  
+     */
   getHydrationPlan() {
     return this.context.hydration.getPlan();
   }
   /**
-   * Gets the Abstract Syntax Tree (AST) representation of the query
-   * @returns Query AST with hydration applied
-   */
+  
+     * Gets the Abstract Syntax Tree (AST) representation of the query
+  
+     * @returns Query AST with hydration applied
+  
+     */
   getAST() {
     return this.context.hydration.applyToAst(this.context.state.ast);
   }
@@ -5768,12 +5945,47 @@ var SQL_OPERATOR_REGISTRY = {
   [SQL_OPERATORS.NOT_EXISTS]: { sql: SQL_OPERATORS.NOT_EXISTS, tsName: "notExists" }
 };
 
+// src/codegen/naming-strategy.ts
+var DefaultNamingStrategy = class {
+  /**
+   * Converts table names to TypeScript symbols
+   * @param table - Table node, function table node, or string name
+   * @returns Capitalized table name (handles schema-qualified names)
+   */
+  tableToSymbol(table) {
+    const tableName = typeof table === "string" ? table : table.name;
+    if (tableName.includes(".")) {
+      return tableName.split(".").map((part) => this.capitalize(part)).join("");
+    }
+    return this.capitalize(tableName);
+  }
+  /**
+   * Converts column references to property names
+   * @param column - Column node
+   * @returns Column name as-is (for backward compatibility)
+   */
+  columnToProperty(column) {
+    return column.name;
+  }
+  /**
+   * Capitalizes the first letter of a string
+   * @param s - String to capitalize
+   * @returns Capitalized string
+   */
+  capitalize(s) {
+    if (!s) return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  }
+};
+
 // src/codegen/typescript.ts
-var capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 var assertNever2 = (value) => {
   throw new Error(`Unhandled SQL operator: ${value}`);
 };
 var TypeScriptGenerator = class {
+  constructor(namingStrategy = new DefaultNamingStrategy()) {
+    this.namingStrategy = namingStrategy;
+  }
   /**
    * Generates TypeScript code from a query AST
    * @param ast - Query AST to generate code from
@@ -5804,9 +6016,9 @@ var TypeScriptGenerator = class {
       lines.push(`  ${sel}${index < selections.length - 1 ? "," : ""}`);
     });
     lines.push(`})`);
-    lines.push(`.from(${capitalize(ast.from.name)})`);
+    lines.push(`.from(${this.namingStrategy.tableToSymbol(ast.from)})`);
     if (ast.distinct && ast.distinct.length) {
-      const cols = ast.distinct.map((c) => `${capitalize(c.table)}.${c.name}`).join(", ");
+      const cols = ast.distinct.map((c) => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(", ");
       lines.push(`.distinct(${cols})`);
     }
     ast.joins.forEach((join) => {
@@ -5821,7 +6033,7 @@ var TypeScriptGenerator = class {
           lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
         }
       } else {
-        const table = capitalize(join.table.name);
+        const table = this.namingStrategy.tableToSymbol(join.table);
         const cond = this.printExpression(join.condition);
         let method = "innerJoin";
         if (join.kind === "LEFT") method = "leftJoin";
@@ -5842,7 +6054,7 @@ var TypeScriptGenerator = class {
       lines.push(`.where(${this.printExpression(ast.where)})`);
     }
     if (ast.groupBy && ast.groupBy.length) {
-      const cols = ast.groupBy.map((c) => `${capitalize(c.table)}.${c.name}`).join(", ");
+      const cols = ast.groupBy.map((c) => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(", ");
       lines.push(`.groupBy(${cols})`);
     }
     if (ast.having) {
@@ -5850,7 +6062,7 @@ var TypeScriptGenerator = class {
     }
     if (ast.orderBy && ast.orderBy.length) {
       ast.orderBy.forEach((o) => {
-        lines.push(`.orderBy(${capitalize(o.column.table)}.${o.column.name}, '${o.direction}')`);
+        lines.push(`.orderBy(${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name}, '${o.direction}')`);
       });
     }
     if (ast.limit) lines.push(`.limit(${ast.limit})`);
@@ -5989,7 +6201,7 @@ var TypeScriptGenerator = class {
    * @returns TypeScript code representation
    */
   printColumnOperand(column) {
-    return `${capitalize(column.table)}.${column.name}`;
+    return `${this.namingStrategy.tableToSymbol(column.table)}.${column.name}`;
   }
   /**
    * Prints a literal operand to TypeScript code
@@ -6015,7 +6227,7 @@ var TypeScriptGenerator = class {
    * @returns TypeScript code representation
    */
   printJsonPathOperand(json) {
-    return `jsonPath(${capitalize(json.column.table)}.${json.column.name}, '${json.path}')`;
+    return `jsonPath(${this.namingStrategy.tableToSymbol(json.column.table)}.${json.column.name}, '${json.path}')`;
   }
   /**
    * Prints a scalar subquery operand to TypeScript code
@@ -6051,11 +6263,11 @@ var TypeScriptGenerator = class {
     result += ") OVER (";
     const parts = [];
     if (node.partitionBy && node.partitionBy.length > 0) {
-      const partitionClause = "PARTITION BY " + node.partitionBy.map((col2) => `${capitalize(col2.table)}.${col2.name}`).join(", ");
+      const partitionClause = "PARTITION BY " + node.partitionBy.map((col2) => `${this.namingStrategy.tableToSymbol(col2.table)}.${col2.name}`).join(", ");
       parts.push(partitionClause);
     }
     if (node.orderBy && node.orderBy.length > 0) {
-      const orderClause = "ORDER BY " + node.orderBy.map((o) => `${capitalize(o.column.table)}.${o.column.name} ${o.direction}`).join(", ");
+      const orderClause = "ORDER BY " + node.orderBy.map((o) => `${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name} ${o.direction}`).join(", ");
       parts.push(orderClause);
     }
     result += parts.join(" ");
@@ -6084,46 +6296,24 @@ var TypeScriptGenerator = class {
   }
 };
 
-// src/orm/domain-event-bus.ts
-var DomainEventBus = class {
-  constructor(initialHandlers) {
-    this.handlers = /* @__PURE__ */ new Map();
-    const handlers = initialHandlers ?? {};
-    Object.entries(handlers).forEach(([name, list]) => {
-      this.handlers.set(name, [...list]);
-    });
-  }
-  register(name, handler) {
-    const existing = this.handlers.get(name) ?? [];
-    existing.push(handler);
-    this.handlers.set(name, existing);
-  }
-  async dispatch(trackedEntities, ctx) {
-    for (const tracked of trackedEntities) {
-      const entity = tracked.entity;
-      if (!entity.domainEvents || !entity.domainEvents.length) continue;
-      for (const event of entity.domainEvents) {
-        const eventName = this.getEventName(event);
-        const handlers = this.handlers.get(eventName);
-        if (!handlers) continue;
-        for (const handler of handlers) {
-          await handler(event, ctx);
-        }
-      }
-      entity.domainEvents = [];
-    }
-  }
-  getEventName(event) {
-    if (!event) return "Unknown";
-    if (typeof event === "string") return event;
-    return event.constructor?.name ?? "Unknown";
-  }
+// src/orm/entity-metadata.ts
+var metadataMap = /* @__PURE__ */ new Map();
+var getEntityMetadata = (target) => {
+  return metadataMap.get(target);
 };
-var addDomainEvent = (entity, event) => {
-  if (!entity.domainEvents) {
-    entity.domainEvents = [];
+
+// src/decorators/bootstrap.ts
+var getTableDefFromEntity = (ctor) => {
+  const meta = getEntityMetadata(ctor);
+  if (!meta) return void 0;
+  return meta.table;
+};
+var selectFromEntity = (ctor) => {
+  const table = getTableDefFromEntity(ctor);
+  if (!table) {
+    throw new Error("Entity metadata has not been bootstrapped");
   }
-  entity.domainEvents.push(event);
+  return new SelectQueryBuilder(table);
 };
 
 // src/orm/identity-map.ts
@@ -6153,272 +6343,121 @@ var IdentityMap = class {
     const bucket = this.buckets.get(table.name);
     return bucket ? Array.from(bucket.values()) : [];
   }
+  clear() {
+    this.buckets.clear();
+  }
   toIdentityKey(pk) {
     return String(pk);
   }
 };
 
-// src/orm/relation-change-processor.ts
-var RelationChangeProcessor = class {
-  constructor(unitOfWork, dialect, executor) {
-    this.unitOfWork = unitOfWork;
+// src/orm/runtime-types.ts
+var EntityStatus = /* @__PURE__ */ ((EntityStatus2) => {
+  EntityStatus2["New"] = "new";
+  EntityStatus2["Managed"] = "managed";
+  EntityStatus2["Dirty"] = "dirty";
+  EntityStatus2["Removed"] = "removed";
+  EntityStatus2["Detached"] = "detached";
+  return EntityStatus2;
+})(EntityStatus || {});
+
+// src/orm/unit-of-work.ts
+var UnitOfWork = class {
+  constructor(dialect, executor, identityMap, hookContext) {
     this.dialect = dialect;
     this.executor = executor;
-    this.relationChanges = [];
+    this.identityMap = identityMap;
+    this.hookContext = hookContext;
+    this.trackedEntities = /* @__PURE__ */ new Map();
   }
-  registerChange(entry) {
-    this.relationChanges.push(entry);
+  get identityBuckets() {
+    return this.identityMap.bucketsMap;
   }
-  async process() {
-    if (!this.relationChanges.length) return;
-    const entries = [...this.relationChanges];
-    this.relationChanges.length = 0;
-    for (const entry of entries) {
-      switch (entry.relation.type) {
-        case RelationKinds.HasMany:
-          await this.handleHasManyChange(entry);
+  getTracked() {
+    return Array.from(this.trackedEntities.values());
+  }
+  getEntity(table, pk) {
+    return this.identityMap.getEntity(table, pk);
+  }
+  getEntitiesForTable(table) {
+    return this.identityMap.getEntitiesForTable(table);
+  }
+  findTracked(entity) {
+    return this.trackedEntities.get(entity);
+  }
+  setEntity(table, pk, entity) {
+    if (pk === null || pk === void 0) return;
+    let tracked = this.trackedEntities.get(entity);
+    if (!tracked) {
+      tracked = {
+        table,
+        entity,
+        pk,
+        status: "managed" /* Managed */,
+        original: this.createSnapshot(table, entity)
+      };
+      this.trackedEntities.set(entity, tracked);
+    } else {
+      tracked.pk = pk;
+    }
+    this.registerIdentity(tracked);
+  }
+  trackNew(table, entity, pk) {
+    const tracked = {
+      table,
+      entity,
+      pk: pk ?? null,
+      status: "new" /* New */,
+      original: null
+    };
+    this.trackedEntities.set(entity, tracked);
+    if (pk != null) {
+      this.registerIdentity(tracked);
+    }
+  }
+  trackManaged(table, pk, entity) {
+    const tracked = {
+      table,
+      entity,
+      pk,
+      status: "managed" /* Managed */,
+      original: this.createSnapshot(table, entity)
+    };
+    this.trackedEntities.set(entity, tracked);
+    this.registerIdentity(tracked);
+  }
+  markDirty(entity) {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    if (tracked.status === "new" /* New */ || tracked.status === "removed" /* Removed */) return;
+    tracked.status = "dirty" /* Dirty */;
+  }
+  markRemoved(entity) {
+    const tracked = this.trackedEntities.get(entity);
+    if (!tracked) return;
+    tracked.status = "removed" /* Removed */;
+  }
+  async flush() {
+    const toFlush = Array.from(this.trackedEntities.values());
+    for (const tracked of toFlush) {
+      switch (tracked.status) {
+        case "new" /* New */:
+          await this.flushInsert(tracked);
           break;
-        case RelationKinds.HasOne:
-          await this.handleHasOneChange(entry);
+        case "dirty" /* Dirty */:
+          await this.flushUpdate(tracked);
           break;
-        case RelationKinds.BelongsToMany:
-          await this.handleBelongsToManyChange(entry);
+        case "removed" /* Removed */:
+          await this.flushDelete(tracked);
           break;
-        case RelationKinds.BelongsTo:
-          await this.handleBelongsToChange(entry);
+        default:
           break;
       }
     }
   }
-  async handleHasManyChange(entry) {
-    const relation = entry.relation;
-    const target = entry.change.entity;
-    if (!target) return;
-    const tracked = this.unitOfWork.findTracked(target);
-    if (!tracked) return;
-    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
-    const rootValue = entry.root[localKey];
-    if (rootValue === void 0 || rootValue === null) return;
-    if (entry.change.kind === "add" || entry.change.kind === "attach") {
-      this.assignHasManyForeignKey(tracked.entity, relation, rootValue);
-      this.unitOfWork.markDirty(tracked.entity);
-      return;
-    }
-    if (entry.change.kind === "remove") {
-      this.detachHasManyChild(tracked.entity, relation);
-    }
-  }
-  async handleHasOneChange(entry) {
-    const relation = entry.relation;
-    const target = entry.change.entity;
-    if (!target) return;
-    const tracked = this.unitOfWork.findTracked(target);
-    if (!tracked) return;
-    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
-    const rootValue = entry.root[localKey];
-    if (rootValue === void 0 || rootValue === null) return;
-    if (entry.change.kind === "attach" || entry.change.kind === "add") {
-      this.assignHasOneForeignKey(tracked.entity, relation, rootValue);
-      this.unitOfWork.markDirty(tracked.entity);
-      return;
-    }
-    if (entry.change.kind === "remove") {
-      this.detachHasOneChild(tracked.entity, relation);
-    }
-  }
-  async handleBelongsToChange(_entry) {
-  }
-  async handleBelongsToManyChange(entry) {
-    const relation = entry.relation;
-    const rootKey = relation.localKey || findPrimaryKey(entry.rootTable);
-    const rootId = entry.root[rootKey];
-    if (rootId === void 0 || rootId === null) return;
-    const targetId = this.resolvePrimaryKeyValue(entry.change.entity, relation.target);
-    if (targetId === null) return;
-    if (entry.change.kind === "attach" || entry.change.kind === "add") {
-      await this.insertPivotRow(relation, rootId, targetId);
-      return;
-    }
-    if (entry.change.kind === "detach" || entry.change.kind === "remove") {
-      await this.deletePivotRow(relation, rootId, targetId);
-      if (relation.cascade === "all" || relation.cascade === "remove") {
-        this.unitOfWork.markRemoved(entry.change.entity);
-      }
-    }
-  }
-  assignHasManyForeignKey(child, relation, rootValue) {
-    const current = child[relation.foreignKey];
-    if (current === rootValue) return;
-    child[relation.foreignKey] = rootValue;
-  }
-  detachHasManyChild(child, relation) {
-    if (relation.cascade === "all" || relation.cascade === "remove") {
-      this.unitOfWork.markRemoved(child);
-      return;
-    }
-    child[relation.foreignKey] = null;
-    this.unitOfWork.markDirty(child);
-  }
-  assignHasOneForeignKey(child, relation, rootValue) {
-    const current = child[relation.foreignKey];
-    if (current === rootValue) return;
-    child[relation.foreignKey] = rootValue;
-  }
-  detachHasOneChild(child, relation) {
-    if (relation.cascade === "all" || relation.cascade === "remove") {
-      this.unitOfWork.markRemoved(child);
-      return;
-    }
-    child[relation.foreignKey] = null;
-    this.unitOfWork.markDirty(child);
-  }
-  async insertPivotRow(relation, rootId, targetId) {
-    const payload = {
-      [relation.pivotForeignKeyToRoot]: rootId,
-      [relation.pivotForeignKeyToTarget]: targetId
-    };
-    const builder = new InsertQueryBuilder(relation.pivotTable).values(payload);
-    const compiled = builder.compile(this.dialect);
-    await this.executor.executeSql(compiled.sql, compiled.params);
-  }
-  async deletePivotRow(relation, rootId, targetId) {
-    const rootCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
-    const targetCol = relation.pivotTable.columns[relation.pivotForeignKeyToTarget];
-    if (!rootCol || !targetCol) return;
-    const builder = new DeleteQueryBuilder(relation.pivotTable).where(
-      and(eq(rootCol, rootId), eq(targetCol, targetId))
-    );
-    const compiled = builder.compile(this.dialect);
-    await this.executor.executeSql(compiled.sql, compiled.params);
-  }
-  resolvePrimaryKeyValue(entity, table) {
-    if (!entity) return null;
-    const key = findPrimaryKey(table);
-    const value = entity[key];
-    if (value === void 0 || value === null) return null;
-    return value;
-  }
-};
-
-// src/orm/transaction-runner.ts
-var runInTransaction = async (executor, action) => {
-  if (!executor.beginTransaction) {
-    await action();
-    return;
-  }
-  await executor.beginTransaction();
-  try {
-    await action();
-    await executor.commitTransaction?.();
-  } catch (error) {
-    await executor.rollbackTransaction?.();
-    throw error;
-  }
-};
-
-// src/orm/runtime-types.ts
-var EntityStatus = /* @__PURE__ */ ((EntityStatus2) => {
-  EntityStatus2["New"] = "new";
-  EntityStatus2["Managed"] = "managed";
-  EntityStatus2["Dirty"] = "dirty";
-  EntityStatus2["Removed"] = "removed";
-  EntityStatus2["Detached"] = "detached";
-  return EntityStatus2;
-})(EntityStatus || {});
-
-// src/orm/unit-of-work.ts
-var UnitOfWork = class {
-  constructor(dialect, executor, identityMap, hookContext) {
-    this.dialect = dialect;
-    this.executor = executor;
-    this.identityMap = identityMap;
-    this.hookContext = hookContext;
-    this.trackedEntities = /* @__PURE__ */ new Map();
-  }
-  get identityBuckets() {
-    return this.identityMap.bucketsMap;
-  }
-  getTracked() {
-    return Array.from(this.trackedEntities.values());
-  }
-  getEntity(table, pk) {
-    return this.identityMap.getEntity(table, pk);
-  }
-  getEntitiesForTable(table) {
-    return this.identityMap.getEntitiesForTable(table);
-  }
-  findTracked(entity) {
-    return this.trackedEntities.get(entity);
-  }
-  setEntity(table, pk, entity) {
-    if (pk === null || pk === void 0) return;
-    let tracked = this.trackedEntities.get(entity);
-    if (!tracked) {
-      tracked = {
-        table,
-        entity,
-        pk,
-        status: "managed" /* Managed */,
-        original: this.createSnapshot(table, entity)
-      };
-      this.trackedEntities.set(entity, tracked);
-    } else {
-      tracked.pk = pk;
-    }
-    this.registerIdentity(tracked);
-  }
-  trackNew(table, entity, pk) {
-    const tracked = {
-      table,
-      entity,
-      pk: pk ?? null,
-      status: "new" /* New */,
-      original: null
-    };
-    this.trackedEntities.set(entity, tracked);
-    if (pk != null) {
-      this.registerIdentity(tracked);
-    }
-  }
-  trackManaged(table, pk, entity) {
-    const tracked = {
-      table,
-      entity,
-      pk,
-      status: "managed" /* Managed */,
-      original: this.createSnapshot(table, entity)
-    };
-    this.trackedEntities.set(entity, tracked);
-    this.registerIdentity(tracked);
-  }
-  markDirty(entity) {
-    const tracked = this.trackedEntities.get(entity);
-    if (!tracked) return;
-    if (tracked.status === "new" /* New */ || tracked.status === "removed" /* Removed */) return;
-    tracked.status = "dirty" /* Dirty */;
-  }
-  markRemoved(entity) {
-    const tracked = this.trackedEntities.get(entity);
-    if (!tracked) return;
-    tracked.status = "removed" /* Removed */;
-  }
-  async flush() {
-    const toFlush = Array.from(this.trackedEntities.values());
-    for (const tracked of toFlush) {
-      switch (tracked.status) {
-        case "new" /* New */:
-          await this.flushInsert(tracked);
-          break;
-        case "dirty" /* Dirty */:
-          await this.flushUpdate(tracked);
-          break;
-        case "removed" /* Removed */:
-          await this.flushDelete(tracked);
-          break;
-        default:
-          break;
-      }
-    }
+  reset() {
+    this.trackedEntities.clear();
+    this.identityMap.clear();
   }
   async flushInsert(tracked) {
     await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
@@ -6539,6 +6578,193 @@ var UnitOfWork = class {
   }
 };
 
+// src/orm/domain-event-bus.ts
+var DomainEventBus = class {
+  constructor(initialHandlers) {
+    this.handlers = /* @__PURE__ */ new Map();
+    const handlers = initialHandlers ?? {};
+    Object.entries(handlers).forEach(([name, list]) => {
+      this.handlers.set(name, [...list]);
+    });
+  }
+  register(name, handler) {
+    const existing = this.handlers.get(name) ?? [];
+    existing.push(handler);
+    this.handlers.set(name, existing);
+  }
+  async dispatch(trackedEntities, ctx) {
+    for (const tracked of trackedEntities) {
+      const entity = tracked.entity;
+      if (!entity.domainEvents || !entity.domainEvents.length) continue;
+      for (const event of entity.domainEvents) {
+        const eventName = this.getEventName(event);
+        const handlers = this.handlers.get(eventName);
+        if (!handlers) continue;
+        for (const handler of handlers) {
+          await handler(event, ctx);
+        }
+      }
+      entity.domainEvents = [];
+    }
+  }
+  getEventName(event) {
+    if (!event) return "Unknown";
+    if (typeof event === "string") return event;
+    return event.constructor?.name ?? "Unknown";
+  }
+};
+var addDomainEvent = (entity, event) => {
+  if (!entity.domainEvents) {
+    entity.domainEvents = [];
+  }
+  entity.domainEvents.push(event);
+};
+
+// src/orm/relation-change-processor.ts
+var RelationChangeProcessor = class {
+  constructor(unitOfWork, dialect, executor) {
+    this.unitOfWork = unitOfWork;
+    this.dialect = dialect;
+    this.executor = executor;
+    this.relationChanges = [];
+  }
+  registerChange(entry) {
+    this.relationChanges.push(entry);
+  }
+  reset() {
+    this.relationChanges.length = 0;
+  }
+  async process() {
+    if (!this.relationChanges.length) return;
+    const entries = [...this.relationChanges];
+    this.relationChanges.length = 0;
+    for (const entry of entries) {
+      switch (entry.relation.type) {
+        case RelationKinds.HasMany:
+          await this.handleHasManyChange(entry);
+          break;
+        case RelationKinds.HasOne:
+          await this.handleHasOneChange(entry);
+          break;
+        case RelationKinds.BelongsToMany:
+          await this.handleBelongsToManyChange(entry);
+          break;
+        case RelationKinds.BelongsTo:
+          await this.handleBelongsToChange(entry);
+          break;
+      }
+    }
+  }
+  async handleHasManyChange(entry) {
+    const relation = entry.relation;
+    const target = entry.change.entity;
+    if (!target) return;
+    const tracked = this.unitOfWork.findTracked(target);
+    if (!tracked) return;
+    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootValue = entry.root[localKey];
+    if (rootValue === void 0 || rootValue === null) return;
+    if (entry.change.kind === "add" || entry.change.kind === "attach") {
+      this.assignHasManyForeignKey(tracked.entity, relation, rootValue);
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+    if (entry.change.kind === "remove") {
+      this.detachHasManyChild(tracked.entity, relation);
+    }
+  }
+  async handleHasOneChange(entry) {
+    const relation = entry.relation;
+    const target = entry.change.entity;
+    if (!target) return;
+    const tracked = this.unitOfWork.findTracked(target);
+    if (!tracked) return;
+    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootValue = entry.root[localKey];
+    if (rootValue === void 0 || rootValue === null) return;
+    if (entry.change.kind === "attach" || entry.change.kind === "add") {
+      this.assignHasOneForeignKey(tracked.entity, relation, rootValue);
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+    if (entry.change.kind === "remove") {
+      this.detachHasOneChild(tracked.entity, relation);
+    }
+  }
+  async handleBelongsToChange(_entry) {
+  }
+  async handleBelongsToManyChange(entry) {
+    const relation = entry.relation;
+    const rootKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootId = entry.root[rootKey];
+    if (rootId === void 0 || rootId === null) return;
+    const targetId = this.resolvePrimaryKeyValue(entry.change.entity, relation.target);
+    if (targetId === null) return;
+    if (entry.change.kind === "attach" || entry.change.kind === "add") {
+      await this.insertPivotRow(relation, rootId, targetId);
+      return;
+    }
+    if (entry.change.kind === "detach" || entry.change.kind === "remove") {
+      await this.deletePivotRow(relation, rootId, targetId);
+      if (relation.cascade === "all" || relation.cascade === "remove") {
+        this.unitOfWork.markRemoved(entry.change.entity);
+      }
+    }
+  }
+  assignHasManyForeignKey(child, relation, rootValue) {
+    const current = child[relation.foreignKey];
+    if (current === rootValue) return;
+    child[relation.foreignKey] = rootValue;
+  }
+  detachHasManyChild(child, relation) {
+    if (relation.cascade === "all" || relation.cascade === "remove") {
+      this.unitOfWork.markRemoved(child);
+      return;
+    }
+    child[relation.foreignKey] = null;
+    this.unitOfWork.markDirty(child);
+  }
+  assignHasOneForeignKey(child, relation, rootValue) {
+    const current = child[relation.foreignKey];
+    if (current === rootValue) return;
+    child[relation.foreignKey] = rootValue;
+  }
+  detachHasOneChild(child, relation) {
+    if (relation.cascade === "all" || relation.cascade === "remove") {
+      this.unitOfWork.markRemoved(child);
+      return;
+    }
+    child[relation.foreignKey] = null;
+    this.unitOfWork.markDirty(child);
+  }
+  async insertPivotRow(relation, rootId, targetId) {
+    const payload = {
+      [relation.pivotForeignKeyToRoot]: rootId,
+      [relation.pivotForeignKeyToTarget]: targetId
+    };
+    const builder = new InsertQueryBuilder(relation.pivotTable).values(payload);
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+  async deletePivotRow(relation, rootId, targetId) {
+    const rootCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+    const targetCol = relation.pivotTable.columns[relation.pivotForeignKeyToTarget];
+    if (!rootCol || !targetCol) return;
+    const builder = new DeleteQueryBuilder(relation.pivotTable).where(
+      and(eq(rootCol, rootId), eq(targetCol, targetId))
+    );
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+  resolvePrimaryKeyValue(entity, table) {
+    if (!entity) return null;
+    const key = findPrimaryKey(table);
+    const value = entity[key];
+    if (value === void 0 || value === null) return null;
+    return value;
+  }
+};
+
 // src/orm/query-logger.ts
 var createQueryLoggingExecutor = (executor, logger) => {
   if (!logger) {
@@ -6562,31 +6788,40 @@ var createQueryLoggingExecutor = (executor, logger) => {
   return wrapped;
 };
 
-// src/orm/orm-context.ts
-var OrmContext = class {
-  constructor(options) {
-    this.options = options;
+// src/orm/transaction-runner.ts
+var runInTransaction = async (executor, action) => {
+  if (!executor.beginTransaction) {
+    await action();
+    return;
+  }
+  await executor.beginTransaction();
+  try {
+    await action();
+    await executor.commitTransaction?.();
+  } catch (error) {
+    await executor.rollbackTransaction?.();
+    throw error;
+  }
+};
+
+// src/orm/orm-session.ts
+var OrmSession = class {
+  constructor(opts) {
+    this.registerRelationChange = (root, relationKey, rootTable, relationName, relation, change) => {
+      this.relationChanges.registerChange(
+        buildRelationChangeEntry(root, relationKey, rootTable, relationName, relation, change)
+      );
+    };
+    this.orm = opts.orm;
+    this.executor = createQueryLoggingExecutor(opts.executor, opts.queryLogger);
+    this.interceptors = [...opts.interceptors ?? []];
     this.identityMap = new IdentityMap();
-    this.interceptors = [...options.interceptors ?? []];
-    this.executorWithLogging = createQueryLoggingExecutor(options.executor, options.queryLogger);
-    this.unitOfWork = new UnitOfWork(
-      options.dialect,
-      this.executorWithLogging,
-      this.identityMap,
-      () => this
-    );
-    this.relationChanges = new RelationChangeProcessor(
-      this.unitOfWork,
-      options.dialect,
-      this.executorWithLogging
-    );
-    this.domainEvents = new DomainEventBus(options.domainEventHandlers);
+    this.unitOfWork = new UnitOfWork(this.orm.dialect, this.executor, this.identityMap, () => this);
+    this.relationChanges = new RelationChangeProcessor(this.unitOfWork, this.orm.dialect, this.executor);
+    this.domainEvents = new DomainEventBus(opts.domainEventHandlers);
   }
   get dialect() {
-    return this.options.dialect;
-  }
-  get executor() {
-    return this.executorWithLogging;
+    return this.orm.dialect;
   }
   get identityBuckets() {
     return this.unitOfWork.identityBuckets;
@@ -6612,16 +6847,8 @@ var OrmContext = class {
   markRemoved(entity) {
     this.unitOfWork.markRemoved(entity);
   }
-  registerRelationChange(root, relationKey, rootTable, relationName, relation, change) {
-    const entry = {
-      root,
-      relationKey,
-      rootTable,
-      relationName,
-      relation,
-      change
-    };
-    this.relationChanges.registerChange(entry);
+  getEntitiesForTable(table) {
+    return this.unitOfWork.getEntitiesForTable(table);
   }
   registerInterceptor(interceptor) {
     this.interceptors.push(interceptor);
@@ -6629,7 +6856,51 @@ var OrmContext = class {
   registerDomainEventHandler(name, handler) {
     this.domainEvents.register(name, handler);
   }
-  async saveChanges() {
+  async find(entityClass, id) {
+    const table = getTableDefFromEntity(entityClass);
+    if (!table) {
+      throw new Error("Entity metadata has not been bootstrapped");
+    }
+    const primaryKey = findPrimaryKey(table);
+    const column = table.columns[primaryKey];
+    if (!column) {
+      throw new Error("Entity table does not expose a primary key");
+    }
+    const qb = selectFromEntity(entityClass).where(eq(column, id)).limit(1);
+    const rows = await executeHydrated(this, qb);
+    return rows[0] ?? null;
+  }
+  async findOne(qb) {
+    const limited = qb.limit(1);
+    const rows = await executeHydrated(this, limited);
+    return rows[0] ?? null;
+  }
+  async findMany(qb) {
+    return executeHydrated(this, qb);
+  }
+  async persist(entity) {
+    if (this.unitOfWork.findTracked(entity)) {
+      return;
+    }
+    const table = getTableDefFromEntity(entity.constructor);
+    if (!table) {
+      throw new Error("Entity metadata has not been bootstrapped");
+    }
+    const primaryKey = findPrimaryKey(table);
+    const pkValue = entity[primaryKey];
+    if (pkValue !== void 0 && pkValue !== null) {
+      this.trackManaged(table, pkValue, entity);
+    } else {
+      this.trackNew(table, entity);
+    }
+  }
+  async remove(entity) {
+    this.markRemoved(entity);
+  }
+  async flush() {
+    await this.unitOfWork.flush();
+  }
+  async commit() {
     await runInTransaction(this.executor, async () => {
       for (const interceptor of this.interceptors) {
         await interceptor.beforeFlush?.(this);
@@ -6643,8 +6914,83 @@ var OrmContext = class {
     });
     await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
   }
-  getEntitiesForTable(table) {
-    return this.unitOfWork.getEntitiesForTable(table);
+  async rollback() {
+    await this.executor.rollbackTransaction?.();
+    this.unitOfWork.reset();
+    this.relationChanges.reset();
+  }
+  getExecutionContext() {
+    return {
+      dialect: this.orm.dialect,
+      executor: this.executor,
+      interceptors: this.orm.interceptors
+    };
+  }
+  getHydrationContext() {
+    return {
+      identityMap: this.identityMap,
+      unitOfWork: this.unitOfWork,
+      domainEvents: this.domainEvents,
+      relationChanges: this.relationChanges,
+      entityContext: this
+    };
+  }
+};
+var buildRelationChangeEntry = (root, relationKey, rootTable, relationName, relation, change) => ({
+  root,
+  relationKey,
+  rootTable,
+  relationName,
+  relation,
+  change
+});
+
+// src/orm/interceptor-pipeline.ts
+var InterceptorPipeline = class {
+  constructor() {
+    this.interceptors = [];
+  }
+  use(interceptor) {
+    this.interceptors.push(interceptor);
+  }
+  async run(ctx, executor) {
+    let i = 0;
+    const dispatch = async () => {
+      const interceptor = this.interceptors[i++];
+      if (!interceptor) {
+        return executor.executeSql(ctx.sql, ctx.params);
+      }
+      return interceptor(ctx, dispatch);
+    };
+    return dispatch();
+  }
+};
+
+// src/orm/orm.ts
+var Orm = class {
+  constructor(opts) {
+    this.dialect = opts.dialect;
+    this.interceptors = opts.interceptors ?? new InterceptorPipeline();
+    this.namingStrategy = opts.namingStrategy ?? new DefaultNamingStrategy();
+    this.executorFactory = opts.executorFactory;
+  }
+  createSession(options) {
+    const executor = this.executorFactory.createExecutor(options?.tx);
+    return new OrmSession({ orm: this, executor });
+  }
+  // Nice convenience:
+  async transaction(fn4) {
+    const executor = this.executorFactory.createTransactionalExecutor();
+    const session = new OrmSession({ orm: this, executor });
+    try {
+      const result = await fn4(session);
+      await session.commit();
+      return result;
+    } catch (err) {
+      await session.rollback();
+      throw err;
+    } finally {
+    }
   }
 };
 
@@ -6759,10 +7105,12 @@ export {
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
   DeleteQueryBuilder,
+  DomainEventBus,
   EntityStatus,
   InsertQueryBuilder,
   MySqlDialect,
-  OrmContext,
+  Orm,
+  OrmSession,
   PostgresDialect,
   RelationKinds,
   SelectQueryBuilder,
@@ -6804,6 +7152,7 @@ export {
   createMssqlExecutor,
   createMysqlExecutor,
   createPostgresExecutor,
+  createQueryLoggingExecutor,
   createSqliteExecutor,
   currentDate,
   currentTime,
@@ -6821,6 +7170,7 @@ export {
   endOfMonth,
   eq,
   executeHydrated,
+  executeHydratedWithContexts,
   exists,
   exp,
   extract,