metal-orm 1.0.16 → 1.0.18

package/dist/index.cjs

@@ -84,6 +84,7 @@ __export(index_exports, {
   columnOperand: () => columnOperand,
   concat: () => concat,
   concatWs: () => concatWs,
+  correlateBy: () => correlateBy,
   cos: () => cos,
   cot: () => cot,
   count: () => count,
@@ -112,6 +113,7 @@ __export(index_exports, {
   diffSchema: () => diffSchema,
   endOfMonth: () => endOfMonth,
   eq: () => eq,
+  esel: () => esel,
   executeHydrated: () => executeHydrated,
   executeHydratedWithContexts: () => executeHydratedWithContexts,
   exists: () => exists,
@@ -123,6 +125,7 @@ __export(index_exports, {
   generateCreateTableSql: () => generateCreateTableSql,
   generateSchemaSql: () => generateSchemaSql,
   getSchemaIntrospector: () => getSchemaIntrospector,
+  groupConcat: () => groupConcat,
   gt: () => gt,
   gte: () => gte,
   hasMany: () => hasMany,
@@ -137,6 +140,7 @@ __export(index_exports, {
   isNotNull: () => isNotNull,
   isNull: () => isNull,
   isOperandNode: () => isOperandNode,
+  isValueOperandInput: () => isValueOperandInput,
   isWindowFunctionNode: () => isWindowFunctionNode,
   jsonPath: () => jsonPath,
   lag: () => lag,
@@ -159,6 +163,8 @@ __export(index_exports, {
   lt: () => lt,
   lte: () => lte,
   ltrim: () => ltrim,
+  max: () => max,
+  min: () => min,
   mod: () => mod,
   month: () => month,
   neq: () => neq,
@@ -169,6 +175,7 @@ __export(index_exports, {
   now: () => now,
   ntile: () => ntile,
   or: () => or,
+  outerRef: () => outerRef,
   pi: () => pi,
   position: () => position,
   pow: () => pow,
@@ -189,6 +196,7 @@ __export(index_exports, {
   rowsToQueryResult: () => rowsToQueryResult,
   rpad: () => rpad,
   rtrim: () => rtrim,
+  sel: () => sel,
   sign: () => sign,
   sin: () => sin,
   space: () => space,
@@ -273,6 +281,30 @@ var col = {
    * Creates a UUID column definition
    */
   uuid: () => ({ name: "", type: "UUID" }),
+  /**
+   * Creates a binary large object column definition
+   */
+  blob: () => ({ name: "", type: "BLOB" }),
+  /**
+   * Creates a fixed-length binary column definition
+   */
+  binary: (length2) => ({
+    name: "",
+    type: "BINARY",
+    args: length2 !== void 0 ? [length2] : void 0
+  }),
+  /**
+   * Creates a variable-length binary column definition
+   */
+  varbinary: (length2) => ({
+    name: "",
+    type: "VARBINARY",
+    args: length2 !== void 0 ? [length2] : void 0
+  }),
+  /**
+   * Creates a Postgres bytea column definition
+   */
+  bytea: () => ({ name: "", type: "BYTEA" }),
   /**
    * Creates a timestamp column definition
    */
@@ -422,10 +454,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;
@@ -436,14 +471,20 @@ 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);
 };
 var columnOperand = (col2) => toNode(col2);
+var outerRef = (col2) => ({
+  ...columnOperand(col2),
+  scope: "outer"
+});
+var correlateBy = (table, column) => outerRef({ name: column, table });
 var createBinaryExpression = (operator, left2, right2, escape) => {
   const node = {
     type: "BinaryExpression",
@@ -585,6 +626,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",
@@ -594,6 +691,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();
@@ -684,13 +795,57 @@ var toTableRef = (table) => ({
   alias: table.alias
 });
 
+// src/core/ast/builders.ts
+var buildColumnNode = (table, column) => {
+  if (column.type === "Column") {
+    return column;
+  }
+  const def = column;
+  const baseTable = def.table ? table.alias && def.table === table.name ? table.alias : def.table : table.alias || table.name;
+  return {
+    type: "Column",
+    table: baseTable,
+    name: def.name
+  };
+};
+var buildColumnNodes = (table, names) => names.map((name) => ({
+  type: "Column",
+  table: table.alias || table.name,
+  name
+}));
+var createTableNode = (table) => ({
+  type: "Table",
+  name: table.name
+});
+var fnTable = (name, args = [], alias, opts) => ({
+  type: "FunctionTable",
+  name,
+  args,
+  alias,
+  lateral: opts?.lateral,
+  withOrdinality: opts?.withOrdinality,
+  columnAliases: opts?.columnAliases,
+  schema: opts?.schema
+});
+var derivedTable = (query, alias, columnAliases) => ({
+  type: "DerivedTable",
+  query,
+  alias,
+  columnAliases
+});
+
 // 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]})`);
@@ -717,6 +872,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);
@@ -724,6 +880,36 @@ 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
@@ -1070,7 +1256,11 @@ var Dialect = class _Dialect {
     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(", ")})`;
   }
@@ -1333,7 +1523,7 @@ var SqlDialectBase = class extends Dialect {
     return this.returningStrategy.compileReturning(returning, ctx);
   }
   compileInsertColumnList(columns) {
-    return columns.map((column) => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(", ");
+    return columns.map((column) => this.quoteIdentifier(column.name)).join(", ");
   }
   compileInsertValues(values, ctx) {
     return values.map((row) => `(${row.map((value) => this.compileOperand(value, ctx)).join(", ")})`).join(", ");
@@ -1359,7 +1549,7 @@ var SqlDialectBase = class extends Dialect {
   compileUpdateAssignments(assignments, ctx) {
     return assignments.map((assignment) => {
       const col2 = assignment.column;
-      const target = `${this.quoteIdentifier(col2.table)}.${this.quoteIdentifier(col2.name)}`;
+      const target = this.quoteIdentifier(col2.name);
       const value = this.compileOperand(assignment.value, ctx);
       return `${target} = ${value}`;
     }).join(", ");
@@ -1391,12 +1581,29 @@ var SqlDialectBase = class extends Dialect {
     if (tableSource.type === "FunctionTable") {
       return this.compileFunctionTable(tableSource, ctx);
     }
+    if (tableSource.type === "DerivedTable") {
+      return this.compileDerivedTable(tableSource, ctx);
+    }
     return this.compileTableSource(tableSource);
   }
   compileFunctionTable(fn4, ctx) {
     return FunctionTableFormatter.format(fn4, ctx, this);
   }
+  compileDerivedTable(table, ctx) {
+    if (!table.alias) {
+      throw new Error("Derived tables must have an alias.");
+    }
+    const subquery = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
+    const columns = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+    return `(${subquery}) AS ${this.quoteIdentifier(table.alias)}${columns}`;
+  }
   compileTableSource(table) {
+    if (table.type === "FunctionTable") {
+      return this.compileFunctionTable(table);
+    }
+    if (table.type === "DerivedTable") {
+      return this.compileDerivedTable(table);
+    }
     const base = this.compileTableName(table);
     return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
   }
@@ -1493,6 +1700,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})`;
+    });
   }
 };
 
@@ -1737,6 +1952,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})`;
+    });
   }
 };
 
@@ -1771,6 +1992,12 @@ var SqliteDialect = class extends SqlDialectBase {
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;
   }
+  formatReturningColumns(returning) {
+    return returning.map((column) => {
+      const alias = column.alias ? ` AS ${this.quoteIdentifier(column.alias)}` : "";
+      return `${this.quoteIdentifier(column.name)}${alias}`;
+    }).join(", ");
+  }
   supportsReturning() {
     return true;
   }
@@ -1853,6 +2080,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}`;
+    });
   }
 };
 
@@ -1929,6 +2164,9 @@ var SqlServerDialect = class extends Dialect {
     return `UPDATE ${table} SET ${assignments}${whereClause};`;
   }
   compileDeleteAst(ast, ctx) {
+    if (ast.from.type !== "Table") {
+      throw new Error("DELETE only supports base tables in the MSSQL dialect.");
+    }
     const table = this.quoteIdentifier(ast.from.name);
     const whereClause = this.compileWhere(ast.where, ctx);
     return `DELETE FROM ${table}${whereClause};`;
@@ -1952,9 +2190,9 @@ var SqlServerDialect = class extends Dialect {
       return expr;
     }).join(", ");
     const distinct = ast.distinct ? "DISTINCT " : "";
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
+    const from = this.compileTableSource(ast.from, ctx);
     const joins = ast.joins.map((j) => {
-      const table = this.quoteIdentifier(j.table.name);
+      const table = this.compileTableSource(j.table, ctx);
       const cond = this.compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
     }).join(" ");
@@ -1984,6 +2222,21 @@ var SqlServerDialect = class extends Dialect {
     }
     return pagination;
   }
+  compileTableSource(table, ctx) {
+    if (table.type === "FunctionTable") {
+      return FunctionTableFormatter.format(table, ctx, this);
+    }
+    if (table.type === "DerivedTable") {
+      return this.compileDerivedTable(table, ctx);
+    }
+    const base = table.schema ? `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}` : this.quoteIdentifier(table.name);
+    return table.alias ? `${base} AS ${this.quoteIdentifier(table.alias)}` : base;
+  }
+  compileDerivedTable(table, ctx) {
+    const sub = this.compileSelectAst(this.normalizeSelectAst(table.query), ctx).trim().replace(/;$/, "");
+    const cols = table.columnAliases?.length ? ` (${table.columnAliases.map((c) => this.quoteIdentifier(c)).join(", ")})` : "";
+    return `(${sub}) AS ${this.quoteIdentifier(table.alias)}${cols}`;
+  }
   compileCtes(ast, ctx) {
     if (!ast.ctes || ast.ctes.length === 0) return "";
     const defs = ast.ctes.map((cte) => {
@@ -2112,6 +2365,17 @@ var SelectQueryState = class _SelectQueryState {
       joins: [...this.ast.joins ?? [], join]
     });
   }
+  /**
+   * Replaces the FROM clause.
+   * @param from - Table source for the FROM clause
+   * @returns New SelectQueryState with updated FROM
+   */
+  withFrom(from) {
+    return this.clone({
+      ...this.ast,
+      from
+    });
+  }
   /**
    * Adds a WHERE clause to the query
    * @param predicate - WHERE predicate expression
@@ -2222,62 +2486,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 {
   /**
@@ -2660,38 +2868,6 @@ var buildDefaultHydrationPlan = (table) => ({
   relations: []
 });
 
-// src/core/ast/builders.ts
-var buildColumnNode = (table, column) => {
-  if (column.type === "Column") {
-    return column;
-  }
-  const def = column;
-  return {
-    type: "Column",
-    table: def.table || table.name,
-    name: def.name
-  };
-};
-var buildColumnNodes = (table, names) => names.map((name) => ({
-  type: "Column",
-  table: table.name,
-  name
-}));
-var createTableNode = (table) => ({
-  type: "Table",
-  name: table.name
-});
-var fnTable = (name, args = [], alias, opts) => ({
-  type: "FunctionTable",
-  name,
-  args,
-  alias,
-  lateral: opts?.lateral,
-  withOrdinality: opts?.withOrdinality,
-  columnAliases: opts?.columnAliases,
-  schema: opts?.schema
-});
-
 // src/query-builder/raw-column-parser.ts
 var parseRawColumn = (col2, tableName, ctes) => {
   if (col2.includes("(")) {
@@ -2731,6 +2907,8 @@ var QueryAstService = class {
     const existingAliases = new Set(
       this.state.ast.columns.map((c) => c.alias || c.name)
     );
+    const from = this.state.ast.from;
+    const rootTableName = from.type === "Table" && from.alias ? from.alias : this.table.name;
     const newCols = Object.entries(columns).reduce((acc, [alias, val]) => {
       if (existingAliases.has(alias)) return acc;
       if (isExpressionSelectionNode(val)) {
@@ -2738,9 +2916,10 @@ var QueryAstService = class {
         return acc;
       }
       const colDef = val;
+      const resolvedTable = colDef.table && colDef.table === this.table.name && from.type === "Table" && from.alias ? from.alias : colDef.table || rootTableName;
       acc.push({
         type: "Column",
-        table: colDef.table || this.table.name,
+        table: resolvedTable,
         name: colDef.name,
         alias
       });
@@ -2755,7 +2934,9 @@ var QueryAstService = class {
    * @returns Column selection result with updated state and added columns
    */
   selectRaw(cols) {
-    const newCols = cols.map((col2) => parseRawColumn(col2, this.table.name, this.state.ast.ctes));
+    const from = this.state.ast.from;
+    const defaultTable = from.type === "Table" && from.alias ? from.alias : this.table.name;
+    const newCols = cols.map((col2) => parseRawColumn(col2, defaultTable, this.state.ast.ctes));
     const nextState = this.state.withColumns(newCols);
     return { state: nextState, addedColumns: newCols };
   }
@@ -2791,6 +2972,14 @@ var QueryAstService = class {
     };
     return this.state.withSetOperation(op);
   }
+  /**
+   * Replaces the FROM clause for the current query.
+   * @param from - Table source to use in the FROM clause
+   * @returns Updated query state with new FROM
+   */
+  withFrom(from) {
+    return this.state.withFrom(from);
+  }
   /**
    * Selects a subquery as a column
    * @param alias - Alias for the subquery
@@ -2824,7 +3013,9 @@ var QueryAstService = class {
    * @returns Updated query state with GROUP BY clause
    */
   withGroupBy(col2) {
-    const node = buildColumnNode(this.table, col2);
+    const from = this.state.ast.from;
+    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
+    const node = buildColumnNode(tableRef, col2);
     return this.state.withGroupBy([node]);
   }
   /**
@@ -2843,7 +3034,9 @@ var QueryAstService = class {
    * @returns Updated query state with ORDER BY clause
    */
   withOrderBy(col2, direction) {
-    const node = buildColumnNode(this.table, col2);
+    const from = this.state.ast.from;
+    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
+    const node = buildColumnNode(tableRef, col2);
     return this.state.withOrderBy([{ type: "OrderBy", column: node, direction }]);
   }
   /**
@@ -2947,7 +3140,8 @@ var RelationProjectionHelper = class {
 var assertNever = (value) => {
   throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
 };
-var baseRelationCondition = (root, relation) => {
+var baseRelationCondition = (root, relation, rootAlias) => {
+  const rootTable = rootAlias || root.name;
   const defaultLocalKey = relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne ? findPrimaryKey(root) : findPrimaryKey(relation.target);
   const localKey = relation.localKey || defaultLocalKey;
   switch (relation.type) {
@@ -2955,12 +3149,12 @@ var baseRelationCondition = (root, relation) => {
     case RelationKinds.HasOne:
       return eq(
         { type: "Column", table: relation.target.name, name: relation.foreignKey },
-        { type: "Column", table: root.name, name: localKey }
+        { type: "Column", table: rootTable, name: localKey }
       );
     case RelationKinds.BelongsTo:
       return eq(
         { type: "Column", table: relation.target.name, name: localKey },
-        { type: "Column", table: root.name, name: relation.foreignKey }
+        { type: "Column", table: rootTable, name: relation.foreignKey }
       );
     case RelationKinds.BelongsToMany:
       throw new Error("BelongsToMany relations do not support the standard join condition builder");
@@ -2968,12 +3162,13 @@ var baseRelationCondition = (root, relation) => {
       return assertNever(relation);
   }
 };
-var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra) => {
+var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra, rootAlias) => {
   const rootKey = relation.localKey || findPrimaryKey(root);
   const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const rootTable = rootAlias || root.name;
   const pivotCondition = eq(
     { type: "Column", table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: "Column", table: root.name, name: rootKey }
+    { type: "Column", table: rootTable, name: rootKey }
   );
   const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
   let targetCondition = eq(
@@ -2991,12 +3186,12 @@ var buildBelongsToManyJoins = (root, relationName, relation, joinKind, extra) =>
   );
   return [pivotJoin, targetJoin];
 };
-var buildRelationJoinCondition = (root, relation, extra) => {
-  const base = baseRelationCondition(root, relation);
+var buildRelationJoinCondition = (root, relation, extra, rootAlias) => {
+  const base = baseRelationCondition(root, relation, rootAlias);
   return extra ? and(base, extra) : base;
 };
-var buildRelationCorrelation = (root, relation) => {
-  return baseRelationCondition(root, relation);
+var buildRelationCorrelation = (root, relation, rootAlias) => {
+  return baseRelationCondition(root, relation, rootAlias);
 };
 
 // src/core/ast/join-metadata.ts
@@ -3040,7 +3235,7 @@ var RelationService = class {
   match(relationName, predicate) {
     const joined = this.joinRelation(relationName, JOIN_KINDS.INNER, predicate);
     const pk = findPrimaryKey(this.table);
-    const distinctCols = [{ type: "Column", table: this.table.name, name: pk }];
+    const distinctCols = [{ type: "Column", table: this.rootTableName(), name: pk }];
     const existingDistinct = joined.state.ast.distinct ? joined.state.ast.distinct : [];
     const nextState = this.astService(joined.state).withDistinct([...existingDistinct, ...distinctCols]);
     return { state: nextState, hydration: joined.hydration };
@@ -3127,9 +3322,13 @@ var RelationService = class {
    * @param ast - Query AST to modify
    * @returns Modified query AST with relation correlation
    */
-  applyRelationCorrelation(relationName, ast) {
+  applyRelationCorrelation(relationName, ast, additionalCorrelation) {
     const relation = this.getRelation(relationName);
-    const correlation = buildRelationCorrelation(this.table, relation);
+    const rootAlias = this.state.ast.from.type === "Table" ? this.state.ast.from.alias : void 0;
+    let correlation = buildRelationCorrelation(this.table, relation, rootAlias);
+    if (additionalCorrelation) {
+      correlation = and(correlation, additionalCorrelation);
+    }
     const whereInSubquery = ast.where ? and(correlation, ast.where) : correlation;
     return {
       ...ast,
@@ -3146,17 +3345,19 @@ var RelationService = class {
    */
   withJoin(state, relationName, joinKind, extraCondition) {
     const relation = this.getRelation(relationName);
+    const rootAlias = state.ast.from.type === "Table" ? state.ast.from.alias : void 0;
     if (relation.type === RelationKinds.BelongsToMany) {
       const joins = buildBelongsToManyJoins(
         this.table,
         relationName,
         relation,
         joinKind,
-        extraCondition
+        extraCondition,
+        rootAlias
       );
       return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
     }
-    const condition = buildRelationJoinCondition(this.table, relation, extraCondition);
+    const condition = buildRelationJoinCondition(this.table, relation, extraCondition, rootAlias);
     const joinNode = createJoinNode(joinKind, relation.target.name, condition, relationName);
     return this.astService(state).withJoin(joinNode);
   }
@@ -3195,6 +3396,11 @@ var RelationService = class {
   astService(state = this.state) {
     return this.createQueryAstService(this.table, state);
   }
+  rootTableName() {
+    const from = this.state.ast.from;
+    if (from.type === "Table" && from.alias) return from.alias;
+    return this.table.name;
+  }
 };
 
 // src/query-builder/select-query-builder-deps.ts
@@ -3269,7 +3475,9 @@ var ColumnSelector = class {
    * @returns Updated query context with DISTINCT clause
    */
   distinct(context, columns) {
-    const nodes = columns.map((col2) => buildColumnNode(this.env.table, col2));
+    const from = context.state.ast.from;
+    const tableRef = from.type === "Table" && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
+    const nodes = columns.map((col2) => buildColumnNode(tableRef, col2));
     const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
     const nextState = astService.withDistinct(nodes);
     return { state: nextState, hydration: context.hydration };
@@ -3326,8 +3534,8 @@ var RelationManager = class {
    * @param ast - Query AST to modify
    * @returns Modified query AST with relation correlation
    */
-  applyRelationCorrelation(context, relationName, ast) {
-    return this.createService(context).applyRelationCorrelation(relationName, ast);
+  applyRelationCorrelation(context, relationName, ast, additionalCorrelation) {
+    return this.createService(context).applyRelationCorrelation(relationName, ast, additionalCorrelation);
   }
   /**
    * Creates a relation service instance
@@ -4374,9 +4582,30 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   clone(context = this.context, lazyRelations = new Set(this.lazyRelations)) {
     return new _SelectQueryBuilder(this.env.table, context.state, context.hydration, this.env.deps, lazyRelations);
   }
+  /**
+   * Applies an alias to the root FROM table.
+   * @param alias - Alias to apply
+   */
+  as(alias) {
+    const from = this.context.state.ast.from;
+    if (from.type !== "Table") {
+      throw new Error("Cannot alias non-table FROM sources");
+    }
+    const nextFrom = { ...from, alias };
+    const nextContext = this.applyAst(this.context, (service) => service.withFrom(nextFrom));
+    return this.clone(nextContext);
+  }
   resolveQueryNode(query) {
     return typeof query.getAST === "function" ? query.getAST() : query;
   }
+  applyCorrelation(ast, correlation) {
+    if (!correlation) return ast;
+    const combinedWhere = ast.where ? and(correlation, ast.where) : correlation;
+    return {
+      ...ast,
+      where: combinedWhere
+    };
+  }
   createChildBuilder(table) {
     return new _SelectQueryBuilder(table, void 0, void 0, this.env.deps);
   }
@@ -4405,6 +4634,21 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
   select(columns) {
     return this.clone(this.columnSelector.select(this.context, columns));
   }
+  /**
+   * 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
@@ -4453,6 +4697,19 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     const nextContext = this.applyAst(this.context, (service) => service.withCte(name, subAst, columns, true));
     return this.clone(nextContext);
   }
+  /**
+   * Replaces the FROM clause with a derived table (subquery with alias)
+   * @param subquery - Subquery to use as the FROM source
+   * @param alias - Alias for the derived table
+   * @param columnAliases - Optional column alias list
+   * @returns New query builder instance with updated FROM
+   */
+  fromSubquery(subquery, alias, columnAliases) {
+    const subAst = this.resolveQueryNode(subquery);
+    const fromNode = derivedTable(subAst, alias, columnAliases);
+    const nextContext = this.applyAst(this.context, (service) => service.withFrom(fromNode));
+    return this.clone(nextContext);
+  }
   /**
   
      * Selects a subquery as a column
@@ -4468,6 +4725,21 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     const query = this.resolveQueryNode(sub);
     return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
   }
+  /**
+   * Adds a JOIN against a derived table (subquery with alias)
+   * @param subquery - Subquery to join
+   * @param alias - Alias for the derived table
+   * @param condition - Join condition expression
+   * @param joinKind - Join kind (defaults to INNER)
+   * @param columnAliases - Optional column alias list for the derived table
+   * @returns New query builder instance with the derived-table join
+   */
+  joinSubquery(subquery, alias, condition, joinKind = JOIN_KINDS.INNER, columnAliases) {
+    const subAst = this.resolveQueryNode(subquery);
+    const joinNode = createJoinNode(joinKind, derivedTable(subAst, alias, columnAliases), condition);
+    const nextContext = this.applyAst(this.context, (service) => service.withJoin(joinNode));
+    return this.clone(nextContext);
+  }
   /**
   
      * Adds an INNER JOIN to the query
@@ -4565,6 +4837,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);
   }
@@ -4726,9 +5039,10 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
      * @returns New query builder instance with the WHERE EXISTS condition
   
      */
-  whereExists(subquery) {
+  whereExists(subquery, correlate) {
     const subAst = this.resolveQueryNode(subquery);
-    return this.where(exists(subAst));
+    const correlated = this.applyCorrelation(subAst, correlate);
+    return this.where(exists(correlated));
   }
   /**
   
@@ -4739,9 +5053,10 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
      * @returns New query builder instance with the WHERE NOT EXISTS condition
   
      */
-  whereNotExists(subquery) {
+  whereNotExists(subquery, correlate) {
     const subAst = this.resolveQueryNode(subquery);
-    return this.where(notExists(subAst));
+    const correlated = this.applyCorrelation(subAst, correlate);
+    return this.where(notExists(correlated));
   }
   /**
   
@@ -4754,17 +5069,19 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
      * @returns New query builder instance with the relationship existence check
   
      */
-  whereHas(relationName, callback) {
+  whereHas(relationName, callbackOrOptions, maybeOptions) {
     const relation = this.env.table.relations[relationName];
     if (!relation) {
       throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
     }
+    const callback = typeof callbackOrOptions === "function" ? callbackOrOptions : void 0;
+    const options = typeof callbackOrOptions === "function" ? maybeOptions : callbackOrOptions;
     let subQb = this.createChildBuilder(relation.target);
     if (callback) {
       subQb = callback(subQb);
     }
     const subAst = subQb.getAST();
-    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst);
+    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst, options?.correlate);
     return this.where(exists(finalSubAst));
   }
   /**
@@ -4778,17 +5095,19 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
      * @returns New query builder instance with the relationship non-existence check
   
      */
-  whereHasNot(relationName, callback) {
+  whereHasNot(relationName, callbackOrOptions, maybeOptions) {
     const relation = this.env.table.relations[relationName];
     if (!relation) {
       throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
     }
+    const callback = typeof callbackOrOptions === "function" ? callbackOrOptions : void 0;
+    const options = typeof callbackOrOptions === "function" ? maybeOptions : callbackOrOptions;
     let subQb = this.createChildBuilder(relation.target);
     if (callback) {
       subQb = callback(subQb);
     }
     const subAst = subQb.getAST();
-    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst);
+    const finalSubAst = this.relationManager.applyRelationCorrelation(this.context, relationName, subAst, options?.correlate);
     return this.where(notExists(finalSubAst));
   }
   /**
@@ -4840,6 +5159,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) {
@@ -4858,7 +5225,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,
@@ -4909,6 +5284,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;
@@ -4922,14 +5308,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
@@ -6138,7 +6531,7 @@ var DefaultNamingStrategy = class {
    * @returns Capitalized table name (handles schema-qualified names)
    */
   tableToSymbol(table) {
-    const tableName = typeof table === "string" ? table : table.name;
+    const tableName = typeof table === "string" ? table : table.type === "DerivedTable" ? table.alias : table.name;
     if (tableName.includes(".")) {
       return tableName.split(".").map((part) => this.capitalize(part)).join("");
     }
@@ -6197,8 +6590,8 @@ 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(${this.namingStrategy.tableToSymbol(ast.from)})`);
@@ -6481,26 +6874,6 @@ var TypeScriptGenerator = class {
   }
 };
 
-// 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/orm/identity-map.ts
 var IdentityMap = class {
   constructor() {
@@ -6713,6 +7086,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;
@@ -6767,24 +7141,30 @@ var UnitOfWork = class {
 var DomainEventBus = class {
   constructor(initialHandlers) {
     this.handlers = /* @__PURE__ */ new Map();
-    const handlers = initialHandlers ?? {};
-    Object.entries(handlers).forEach(([name, list]) => {
-      this.handlers.set(name, [...list]);
-    });
+    if (initialHandlers) {
+      for (const key in initialHandlers) {
+        const type = key;
+        const list = initialHandlers[type] ?? [];
+        this.handlers.set(type, [...list]);
+      }
+    }
   }
-  register(name, handler) {
-    const existing = this.handlers.get(name) ?? [];
+  on(type, handler) {
+    const key = type;
+    const existing = this.handlers.get(key) ?? [];
     existing.push(handler);
-    this.handlers.set(name, existing);
+    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 || !entity.domainEvents.length) continue;
+      if (!entity.domainEvents?.length) continue;
       for (const event of entity.domainEvents) {
-        const eventName = this.getEventName(event);
-        const handlers = this.handlers.get(eventName);
-        if (!handlers) continue;
+        const handlers = this.handlers.get(event.type);
+        if (!handlers?.length) continue;
         for (const handler of handlers) {
           await handler(event, ctx);
         }
@@ -6792,11 +7172,6 @@ var DomainEventBus = class {
       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) {
@@ -7038,8 +7413,8 @@ var OrmSession = class {
   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);
@@ -7051,7 +7426,11 @@ var OrmSession = class {
     if (!column) {
       throw new Error("Entity table does not expose a primary key");
     }
-    const qb = selectFromEntity(entityClass).where(eq(column, id)).limit(1);
+    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;
   }
@@ -7163,7 +7542,6 @@ var Orm = class {
     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 });
@@ -7327,6 +7705,7 @@ function createMssqlExecutor(client) {
   columnOperand,
   concat,
   concatWs,
+  correlateBy,
   cos,
   cot,
   count,
@@ -7355,6 +7734,7 @@ function createMssqlExecutor(client) {
   diffSchema,
   endOfMonth,
   eq,
+  esel,
   executeHydrated,
   executeHydratedWithContexts,
   exists,
@@ -7366,6 +7746,7 @@ function createMssqlExecutor(client) {
   generateCreateTableSql,
   generateSchemaSql,
   getSchemaIntrospector,
+  groupConcat,
   gt,
   gte,
   hasMany,
@@ -7380,6 +7761,7 @@ function createMssqlExecutor(client) {
   isNotNull,
   isNull,
   isOperandNode,
+  isValueOperandInput,
   isWindowFunctionNode,
   jsonPath,
   lag,
@@ -7402,6 +7784,8 @@ function createMssqlExecutor(client) {
   lt,
   lte,
   ltrim,
+  max,
+  min,
   mod,
   month,
   neq,
@@ -7412,6 +7796,7 @@ function createMssqlExecutor(client) {
   now,
   ntile,
   or,
+  outerRef,
   pi,
   position,
   pow,
@@ -7432,6 +7817,7 @@ function createMssqlExecutor(client) {
   rowsToQueryResult,
   rpad,
   rtrim,
+  sel,
   sign,
   sin,
   space,