metal-orm 1.0.15 → 1.0.17

package/dist/index.js

@@ -237,10 +237,13 @@ var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressi
 
 // src/core/ast/expression-builders.ts
 var valueToOperand = (value) => {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return { type: "Literal", value: value === void 0 ? null : value };
+  if (isOperandNode(value)) {
+    return value;
   }
-  return value;
+  return {
+    type: "Literal",
+    value
+  };
 };
 var toNode = (col2) => {
   if (isOperandNode(col2)) return col2;
@@ -251,10 +254,11 @@ var toLiteralNode = (value) => ({
   type: "Literal",
   value
 });
+var isLiteralValue = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var isValueOperandInput = (value) => isOperandNode(value) || isLiteralValue(value);
 var toOperand = (val) => {
-  if (val === null) return { type: "Literal", value: null };
-  if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
-    return { type: "Literal", value: val };
+  if (isLiteralValue(val)) {
+    return valueToOperand(val);
   }
   return toNode(val);
 };
@@ -400,6 +404,62 @@ var windowFunction = (name, args = [], partitionBy, orderBy) => {
   return buildWindowFunction(name, nodeArgs, partitionNodes, orderNodes);
 };
 
+// src/core/sql/sql.ts
+var SQL_OPERATORS = {
+  /** Equality operator */
+  EQUALS: "=",
+  /** Not equals operator */
+  NOT_EQUALS: "!=",
+  /** Greater than operator */
+  GREATER_THAN: ">",
+  /** Greater than or equal operator */
+  GREATER_OR_EQUAL: ">=",
+  /** Less than operator */
+  LESS_THAN: "<",
+  /** Less than or equal operator */
+  LESS_OR_EQUAL: "<=",
+  /** LIKE pattern matching operator */
+  LIKE: "LIKE",
+  /** NOT LIKE pattern matching operator */
+  NOT_LIKE: "NOT LIKE",
+  /** IN membership operator */
+  IN: "IN",
+  /** NOT IN membership operator */
+  NOT_IN: "NOT IN",
+  /** BETWEEN range operator */
+  BETWEEN: "BETWEEN",
+  /** NOT BETWEEN range operator */
+  NOT_BETWEEN: "NOT BETWEEN",
+  /** IS NULL null check operator */
+  IS_NULL: "IS NULL",
+  /** IS NOT NULL null check operator */
+  IS_NOT_NULL: "IS NOT NULL",
+  /** Logical AND operator */
+  AND: "AND",
+  /** Logical OR operator */
+  OR: "OR",
+  /** EXISTS operator */
+  EXISTS: "EXISTS",
+  /** NOT EXISTS operator */
+  NOT_EXISTS: "NOT EXISTS"
+};
+var JOIN_KINDS = {
+  /** INNER JOIN type */
+  INNER: "INNER",
+  /** LEFT JOIN type */
+  LEFT: "LEFT",
+  /** RIGHT JOIN type */
+  RIGHT: "RIGHT",
+  /** CROSS JOIN type */
+  CROSS: "CROSS"
+};
+var ORDER_DIRECTIONS = {
+  /** Ascending order */
+  ASC: "ASC",
+  /** Descending order */
+  DESC: "DESC"
+};
+
 // src/core/ast/aggregate-functions.ts
 var buildAggregate = (name) => (col2) => ({
   type: "Function",
@@ -409,6 +469,20 @@ var buildAggregate = (name) => (col2) => ({
 var count = buildAggregate("COUNT");
 var sum = buildAggregate("SUM");
 var avg = buildAggregate("AVG");
+var min = buildAggregate("MIN");
+var max = buildAggregate("MAX");
+var toOrderByNode = (order) => ({
+  type: "OrderBy",
+  column: columnOperand(order.column),
+  direction: order.direction ?? ORDER_DIRECTIONS.ASC
+});
+var groupConcat = (col2, options) => ({
+  type: "Function",
+  name: "GROUP_CONCAT",
+  args: [columnOperand(col2)],
+  orderBy: options?.orderBy?.map(toOrderByNode),
+  separator: options?.separator !== void 0 ? valueToOperand(options.separator) : void 0
+});
 
 // src/core/ast/expression-visitor.ts
 var expressionDispatchers = /* @__PURE__ */ new Map();
@@ -500,12 +574,17 @@ var toTableRef = (table) => ({
 });
 
 // src/core/functions/standard-strategy.ts
-var StandardFunctionStrategy = class {
+var StandardFunctionStrategy = class _StandardFunctionStrategy {
   constructor() {
     this.renderers = /* @__PURE__ */ new Map();
     this.registerStandard();
   }
   registerStandard() {
+    this.add("COUNT", ({ compiledArgs }) => `COUNT(${compiledArgs.join(", ")})`);
+    this.add("SUM", ({ compiledArgs }) => `SUM(${compiledArgs[0]})`);
+    this.add("AVG", ({ compiledArgs }) => `AVG(${compiledArgs[0]})`);
+    this.add("MIN", ({ compiledArgs }) => `MIN(${compiledArgs[0]})`);
+    this.add("MAX", ({ compiledArgs }) => `MAX(${compiledArgs[0]})`);
     this.add("ABS", ({ compiledArgs }) => `ABS(${compiledArgs[0]})`);
     this.add("UPPER", ({ compiledArgs }) => `UPPER(${compiledArgs[0]})`);
     this.add("LOWER", ({ compiledArgs }) => `LOWER(${compiledArgs[0]})`);
@@ -532,6 +611,7 @@ var StandardFunctionStrategy = class {
     this.add("DAY_OF_WEEK", ({ compiledArgs }) => `DAYOFWEEK(${compiledArgs[0]})`);
     this.add("WEEK_OF_YEAR", ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})`);
     this.add("DATE_TRUNC", ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})`);
+    this.add("GROUP_CONCAT", (ctx) => this.renderGroupConcat(ctx));
   }
   add(name, renderer) {
     this.renderers.set(name, renderer);
@@ -539,10 +619,40 @@ var StandardFunctionStrategy = class {
   getRenderer(name) {
     return this.renderers.get(name);
   }
+  renderGroupConcat(ctx) {
+    const arg = ctx.compiledArgs[0];
+    const orderClause = this.buildOrderByExpression(ctx);
+    const orderSegment = orderClause ? ` ${orderClause}` : "";
+    const separatorClause = this.formatGroupConcatSeparator(ctx);
+    return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
+  }
+  buildOrderByExpression(ctx) {
+    const orderBy = ctx.node.orderBy;
+    if (!orderBy || orderBy.length === 0) {
+      return "";
+    }
+    const parts = orderBy.map((order) => `${ctx.compileOperand(order.column)} ${order.direction}`);
+    return `ORDER BY ${parts.join(", ")}`;
+  }
+  formatGroupConcatSeparator(ctx) {
+    if (!ctx.node.separator) {
+      return "";
+    }
+    return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
+  }
+  getGroupConcatSeparatorOperand(ctx) {
+    return ctx.node.separator ?? _StandardFunctionStrategy.DEFAULT_GROUP_CONCAT_SEPARATOR;
+  }
+  static {
+    this.DEFAULT_GROUP_CONCAT_SEPARATOR = {
+      type: "Literal",
+      value: ","
+    };
+  }
 };
 
 // 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 +825,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
@@ -856,7 +995,11 @@ var Dialect = class {
     const compiledArgs = fnNode.args.map((arg) => this.compileOperand(arg, ctx));
     const renderer = this.functionStrategy.getRenderer(fnNode.name);
     if (renderer) {
-      return renderer({ node: fnNode, compiledArgs });
+      return renderer({
+        node: fnNode,
+        compiledArgs,
+        compileOperand: (operand) => this.compileOperand(operand, ctx)
+      });
     }
     return `${fnNode.name}(${compiledArgs.join(", ")})`;
   }
@@ -1279,6 +1422,14 @@ var PostgresFunctionStrategy = class extends StandardFunctionStrategy {
       const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
       return `DATE_TRUNC('${partClean}', ${date})`;
     });
+    this.add("GROUP_CONCAT", (ctx) => {
+      const arg = ctx.compiledArgs[0];
+      const orderClause = this.buildOrderByExpression(ctx);
+      const orderSegment = orderClause ? ` ${orderClause}` : "";
+      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+      const separator = ctx.compileOperand(separatorOperand);
+      return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
+    });
   }
 };
 
@@ -1523,6 +1674,12 @@ var SqliteFunctionStrategy = class extends StandardFunctionStrategy {
       }
       return `date(${date}, 'start of ${partClean}')`;
     });
+    this.add("GROUP_CONCAT", (ctx) => {
+      const arg = ctx.compiledArgs[0];
+      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+      const separator = ctx.compileOperand(separatorOperand);
+      return `GROUP_CONCAT(${arg}, ${separator})`;
+    });
   }
 };
 
@@ -1639,6 +1796,14 @@ var MssqlFunctionStrategy = class extends StandardFunctionStrategy {
       const partClean = String(partArg.value).replace(/['"]/g, "").toLowerCase();
       return `DATETRUNC(${partClean}, ${date})`;
     });
+    this.add("GROUP_CONCAT", (ctx) => {
+      const arg = ctx.compiledArgs[0];
+      const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+      const separator = ctx.compileOperand(separatorOperand);
+      const orderClause = this.buildOrderByExpression(ctx);
+      const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : "";
+      return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
+    });
   }
 };
 
@@ -2008,62 +2173,6 @@ var createJoinNode = (kind, tableName, condition, relationName) => ({
   meta: relationName ? { relationName } : void 0
 });
 
-// src/core/sql/sql.ts
-var SQL_OPERATORS = {
-  /** Equality operator */
-  EQUALS: "=",
-  /** Not equals operator */
-  NOT_EQUALS: "!=",
-  /** Greater than operator */
-  GREATER_THAN: ">",
-  /** Greater than or equal operator */
-  GREATER_OR_EQUAL: ">=",
-  /** Less than operator */
-  LESS_THAN: "<",
-  /** Less than or equal operator */
-  LESS_OR_EQUAL: "<=",
-  /** LIKE pattern matching operator */
-  LIKE: "LIKE",
-  /** NOT LIKE pattern matching operator */
-  NOT_LIKE: "NOT LIKE",
-  /** IN membership operator */
-  IN: "IN",
-  /** NOT IN membership operator */
-  NOT_IN: "NOT IN",
-  /** BETWEEN range operator */
-  BETWEEN: "BETWEEN",
-  /** NOT BETWEEN range operator */
-  NOT_BETWEEN: "NOT BETWEEN",
-  /** IS NULL null check operator */
-  IS_NULL: "IS NULL",
-  /** IS NOT NULL null check operator */
-  IS_NOT_NULL: "IS NOT NULL",
-  /** Logical AND operator */
-  AND: "AND",
-  /** Logical OR operator */
-  OR: "OR",
-  /** EXISTS operator */
-  EXISTS: "EXISTS",
-  /** NOT EXISTS operator */
-  NOT_EXISTS: "NOT EXISTS"
-};
-var JOIN_KINDS = {
-  /** INNER JOIN type */
-  INNER: "INNER",
-  /** LEFT JOIN type */
-  LEFT: "LEFT",
-  /** RIGHT JOIN type */
-  RIGHT: "RIGHT",
-  /** CROSS JOIN type */
-  CROSS: "CROSS"
-};
-var ORDER_DIRECTIONS = {
-  /** Ascending order */
-  ASC: "ASC",
-  /** Descending order */
-  DESC: "DESC"
-};
-
 // src/query-builder/hydration-manager.ts
 var HydrationManager = class _HydrationManager {
   /**
@@ -4107,31 +4216,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 +4289,183 @@ 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 columns from the root table by name (typed).
+   * @param cols - Column names on the root table
    */
+  selectColumns(...cols) {
+    const selection = {};
+    for (const key of cols) {
+      const col2 = this.env.table.columns[key];
+      if (!col2) {
+        throw new Error(`Column '${key}' not found on table '${this.env.table.name}'`);
+      }
+      selection[key] = col2;
+    }
+    return this.select(selection);
+  }
+  /**
+  
+     * 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);
@@ -4283,6 +4475,47 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     nextLazy.add(relationName);
     return this.clone(this.context, nextLazy);
   }
+  /**
+   * Selects columns for a related table in a single hop.
+   */
+  selectRelationColumns(relationName, ...cols) {
+    const relation = this.env.table.relations[relationName];
+    if (!relation) {
+      throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
+    }
+    const target = relation.target;
+    for (const col2 of cols) {
+      if (!target.columns[col2]) {
+        throw new Error(
+          `Column '${col2}' not found on related table '${target.name}' for relation '${relationName}'`
+        );
+      }
+    }
+    return this.include(relationName, { columns: cols });
+  }
+  /**
+   * Convenience alias for selecting specific columns from a relation.
+   */
+  includePick(relationName, cols) {
+    return this.selectRelationColumns(relationName, ...cols);
+  }
+  /**
+   * Selects columns for the root table and relations from a single config object.
+   */
+  selectColumnsDeep(config) {
+    let qb = this;
+    if (config.root?.length) {
+      qb = qb.selectColumns(...config.root);
+    }
+    for (const key of Object.keys(config)) {
+      if (key === "root") continue;
+      const relName = key;
+      const cols = config[relName];
+      if (!cols || !cols.length) continue;
+      qb = qb.selectRelationColumns(relName, ...cols);
+    }
+    return qb;
+  }
   getLazyRelations() {
     return Array.from(this.lazyRelations);
   }
@@ -4292,125 +4525,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 +4719,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 +4743,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);
   }
@@ -4478,6 +4791,54 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
 var createColumn = (table, name) => ({ type: "Column", table, name });
 var createLiteral = (val) => ({ type: "Literal", value: val });
 
+// src/orm/entity-metadata.ts
+var metadataMap = /* @__PURE__ */ new Map();
+var getEntityMetadata = (target) => {
+  return metadataMap.get(target);
+};
+
+// 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");
+  }
+  return new SelectQueryBuilder(table);
+};
+
+// src/query-builder/select-helpers.ts
+function sel(table, ...cols) {
+  const selection = {};
+  for (const col2 of cols) {
+    const def = table.columns[col2];
+    if (!def) {
+      throw new Error(`Column '${col2}' not found on table '${table.name}'`);
+    }
+    selection[col2] = def;
+  }
+  return selection;
+}
+function esel(entity, ...props) {
+  const table = getTableDefFromEntity(entity);
+  if (!table) {
+    throw new Error(`No table definition registered for entity '${entity.name}'`);
+  }
+  const selection = {};
+  for (const prop of props) {
+    const col2 = table.columns[prop];
+    if (!col2) {
+      throw new Error(`No column '${prop}' found for entity '${entity.name}'`);
+    }
+    selection[prop] = col2;
+  }
+  return selection;
+}
+
 // src/query-builder/insert-query-state.ts
 var InsertQueryState = class _InsertQueryState {
   constructor(table, ast) {
@@ -4496,7 +4857,15 @@ var InsertQueryState = class _InsertQueryState {
     if (!rows.length) return this;
     const definedColumns = this.ast.columns.length ? this.ast.columns : buildColumnNodes(this.table, Object.keys(rows[0]));
     const newRows = rows.map(
-      (row) => definedColumns.map((column) => valueToOperand(row[column.name]))
+      (row, rowIndex) => definedColumns.map((column) => {
+        const rawValue = row[column.name];
+        if (!isValueOperandInput(rawValue)) {
+          throw new Error(
+            `Invalid insert value for column "${column.name}" in row ${rowIndex}: only primitives, null, or OperandNodes are allowed`
+          );
+        }
+        return valueToOperand(rawValue);
+      })
     );
     return this.clone({
       ...this.ast,
@@ -4547,6 +4916,17 @@ var InsertQueryBuilder = class _InsertQueryBuilder {
 };
 
 // src/query-builder/update-query-state.ts
+var isUpdateValue = (value) => {
+  if (value === null) return true;
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return true;
+    default:
+      return isOperandNode(value);
+  }
+};
 var UpdateQueryState = class _UpdateQueryState {
   constructor(table, ast) {
     this.table = table;
@@ -4560,14 +4940,21 @@ var UpdateQueryState = class _UpdateQueryState {
     return new _UpdateQueryState(this.table, nextAst);
   }
   withSet(values) {
-    const assignments = Object.entries(values).map(([column, value]) => ({
-      column: {
-        type: "Column",
-        table: this.table.name,
-        name: column
-      },
-      value: valueToOperand(value)
-    }));
+    const assignments = Object.entries(values).map(([column, rawValue]) => {
+      if (!isUpdateValue(rawValue)) {
+        throw new Error(
+          `Invalid update value for column "${column}": only primitives, null, or OperandNodes are allowed`
+        );
+      }
+      return {
+        column: {
+          type: "Column",
+          table: this.table.name,
+          name: column
+        },
+        value: valueToOperand(rawValue)
+      };
+    });
     return this.clone({
       ...this.ast,
       set: assignments
@@ -5768,20 +6155,55 @@ var SQL_OPERATOR_REGISTRY = {
   [SQL_OPERATORS.NOT_EXISTS]: { sql: SQL_OPERATORS.NOT_EXISTS, tsName: "notExists" }
 };
 
-// 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 {
+// src/codegen/naming-strategy.ts
+var DefaultNamingStrategy = class {
   /**
-   * Generates TypeScript code from a query AST
-   * @param ast - Query AST to generate code from
-   * @returns Generated TypeScript code
+   * Converts table names to TypeScript symbols
+   * @param table - Table node, function table node, or string name
+   * @returns Capitalized table name (handles schema-qualified names)
    */
-  generate(ast) {
-    const chainLines = this.buildSelectLines(ast);
-    const lines = chainLines.map((line, index) => index === 0 ? `const query = ${line}` : line);
+  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 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
+   * @returns Generated TypeScript code
+   */
+  generate(ast) {
+    const chainLines = this.buildSelectLines(ast);
+    const lines = chainLines.map((line, index) => index === 0 ? `const query = ${line}` : line);
     lines.push(";", "", "await query.execute();");
     return lines.join("\n");
   }
@@ -5800,13 +6222,13 @@ var TypeScriptGenerator = class {
       return `${key}: ${this.printOperand(operand)}`;
     });
     lines.push(`db.select({`);
-    selections.forEach((sel, index) => {
-      lines.push(`  ${sel}${index < selections.length - 1 ? "," : ""}`);
+    selections.forEach((sel2, index) => {
+      lines.push(`  ${sel2}${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 +6243,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 +6264,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 +6272,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 +6411,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 +6437,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 +6473,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,48 +6506,6 @@ 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";
-  }
-};
-var addDomainEvent = (entity, event) => {
-  if (!entity.domainEvents) {
-    entity.domainEvents = [];
-  }
-  entity.domainEvents.push(event);
-};
-
 // src/orm/identity-map.ts
 var IdentityMap = class {
   constructor() {
@@ -6153,169 +6533,14 @@ 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;
-    this.dialect = dialect;
-    this.executor = executor;
-    this.relationChanges = [];
-  }
-  registerChange(entry) {
-    this.relationChanges.push(entry);
-  }
-  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/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";
@@ -6420,6 +6645,10 @@ var UnitOfWork = class {
       }
     }
   }
+  reset() {
+    this.trackedEntities.clear();
+    this.identityMap.clear();
+  }
   async flushInsert(tracked) {
     await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
     const payload = this.extractColumns(tracked.table, tracked.entity);
@@ -6489,6 +6718,7 @@ var UnitOfWork = class {
   extractColumns(table, entity) {
     const payload = {};
     for (const column of Object.keys(table.columns)) {
+      if (entity[column] === void 0) continue;
       payload[column] = entity[column];
     }
     return payload;
@@ -6539,6 +6769,194 @@ var UnitOfWork = class {
   }
 };
 
+// src/orm/domain-event-bus.ts
+var DomainEventBus = class {
+  constructor(initialHandlers) {
+    this.handlers = /* @__PURE__ */ new Map();
+    if (initialHandlers) {
+      for (const key in initialHandlers) {
+        const type = key;
+        const list = initialHandlers[type] ?? [];
+        this.handlers.set(type, [...list]);
+      }
+    }
+  }
+  on(type, handler) {
+    const key = type;
+    const existing = this.handlers.get(key) ?? [];
+    existing.push(handler);
+    this.handlers.set(key, existing);
+  }
+  register(type, handler) {
+    this.on(type, handler);
+  }
+  async dispatch(trackedEntities, ctx) {
+    for (const tracked of trackedEntities) {
+      const entity = tracked.entity;
+      if (!entity.domainEvents?.length) continue;
+      for (const event of entity.domainEvents) {
+        const handlers = this.handlers.get(event.type);
+        if (!handlers?.length) continue;
+        for (const handler of handlers) {
+          await handler(event, ctx);
+        }
+      }
+      entity.domainEvents = [];
+    }
+  }
+};
+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 +6980,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,24 +7039,64 @@ 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);
   }
-  registerDomainEventHandler(name, handler) {
-    this.domainEvents.register(name, handler);
+  registerDomainEventHandler(type, handler) {
+    this.domainEvents.on(type, handler);
+  }
+  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 columnSelections = Object.values(table.columns).reduce((acc, col2) => {
+      acc[col2.name] = col2;
+      return acc;
+    }, {});
+    const qb = selectFromEntity(entityClass).select(columnSelections).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 saveChanges() {
+  async commit() {
     await runInTransaction(this.executor, async () => {
       for (const interceptor of this.interceptors) {
         await interceptor.beforeFlush?.(this);
@@ -6643,8 +7110,82 @@ 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 });
+  }
+  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 +7300,12 @@ export {
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
   DeleteQueryBuilder,
+  DomainEventBus,
   EntityStatus,
   InsertQueryBuilder,
   MySqlDialect,
-  OrmContext,
+  Orm,
+  OrmSession,
   PostgresDialect,
   RelationKinds,
   SelectQueryBuilder,
@@ -6804,6 +7347,7 @@ export {
   createMssqlExecutor,
   createMysqlExecutor,
   createPostgresExecutor,
+  createQueryLoggingExecutor,
   createSqliteExecutor,
   currentDate,
   currentTime,
@@ -6820,7 +7364,9 @@ export {
   diffSchema,
   endOfMonth,
   eq,
+  esel,
   executeHydrated,
+  executeHydratedWithContexts,
   exists,
   exp,
   extract,
@@ -6830,6 +7376,7 @@ export {
   generateCreateTableSql,
   generateSchemaSql,
   getSchemaIntrospector,
+  groupConcat,
   gt,
   gte,
   hasMany,
@@ -6844,6 +7391,7 @@ export {
   isNotNull,
   isNull,
   isOperandNode,
+  isValueOperandInput,
   isWindowFunctionNode,
   jsonPath,
   lag,
@@ -6866,6 +7414,8 @@ export {
   lt,
   lte,
   ltrim,
+  max,
+  min,
   mod,
   month,
   neq,
@@ -6896,6 +7446,7 @@ export {
   rowsToQueryResult,
   rpad,
   rtrim,
+  sel,
   sign,
   sin,
   space,