metal-orm 1.0.16 → 1.0.18

package/dist/decorators/index.js

@@ -298,6 +298,15 @@ var isWindowFunctionNode = (node) => node?.type === "WindowFunction";
 var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
 
 // src/core/ast/expression-builders.ts
+var valueToOperand = (value) => {
+  if (isOperandNode(value)) {
+    return value;
+  }
+  return {
+    type: "Literal",
+    value
+  };
+};
 var toNode = (col) => {
   if (isOperandNode(col)) return col;
   const def = col;
@@ -307,10 +316,10 @@ var toLiteralNode = (value) => ({
   type: "Literal",
   value
 });
+var isLiteralValue = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 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);
 };
@@ -351,6 +360,24 @@ var notExists = (subquery) => ({
   subquery
 });
 
+// src/core/sql/sql.ts
+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) => (col) => ({
   type: "Function",
@@ -360,14 +387,41 @@ var buildAggregate = (name) => (col) => ({
 var count = buildAggregate("COUNT");
 var sum = buildAggregate("SUM");
 var avg = buildAggregate("AVG");
+var min = buildAggregate("MIN");
+var max = buildAggregate("MAX");
+
+// 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 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]})`);
@@ -394,6 +448,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);
@@ -401,6 +456,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
@@ -747,7 +832,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(", ")})`;
   }
@@ -1010,7 +1099,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(", ");
@@ -1036,7 +1125,7 @@ var SqlDialectBase = class extends Dialect {
   compileUpdateAssignments(assignments, ctx) {
     return assignments.map((assignment) => {
       const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const target = this.quoteIdentifier(col.name);
       const value = this.compileOperand(assignment.value, ctx);
       return `${target} = ${value}`;
     }).join(", ");
@@ -1068,12 +1157,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(fn, ctx) {
     return FunctionTableFormatter.format(fn, 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;
   }
@@ -1170,6 +1276,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})`;
+    });
   }
 };
 
@@ -1414,6 +1528,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})`;
+    });
   }
 };
 
@@ -1448,6 +1568,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;
   }
@@ -1530,6 +1656,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}`;
+    });
   }
 };
 
@@ -1606,6 +1740,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};`;
@@ -1629,9 +1766,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(" ");
@@ -1661,6 +1798,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) => {
@@ -1789,6 +1941,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
@@ -1899,24 +2062,6 @@ var createJoinNode = (kind, tableName, condition, relationName) => ({
   meta: relationName ? { relationName } : void 0
 });
 
-// src/core/sql/sql.ts
-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 {
   /**
@@ -2299,19 +2444,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
-  };
-};
-
 // src/query-builder/raw-column-parser.ts
 var parseRawColumn = (col, tableName, ctes) => {
   if (col.includes("(")) {
@@ -2351,6 +2483,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)) {
@@ -2358,9 +2492,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
       });
@@ -2375,7 +2510,9 @@ var QueryAstService = class {
    * @returns Column selection result with updated state and added columns
    */
   selectRaw(cols) {
-    const newCols = cols.map((col) => parseRawColumn(col, 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((col) => parseRawColumn(col, defaultTable, this.state.ast.ctes));
     const nextState = this.state.withColumns(newCols);
     return { state: nextState, addedColumns: newCols };
   }
@@ -2411,6 +2548,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
@@ -2444,7 +2589,9 @@ var QueryAstService = class {
    * @returns Updated query state with GROUP BY clause
    */
   withGroupBy(col) {
-    const node = buildColumnNode(this.table, col);
+    const from = this.state.ast.from;
+    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
+    const node = buildColumnNode(tableRef, col);
     return this.state.withGroupBy([node]);
   }
   /**
@@ -2463,7 +2610,9 @@ var QueryAstService = class {
    * @returns Updated query state with ORDER BY clause
    */
   withOrderBy(col, direction) {
-    const node = buildColumnNode(this.table, col);
+    const from = this.state.ast.from;
+    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
+    const node = buildColumnNode(tableRef, col);
     return this.state.withOrderBy([{ type: "OrderBy", column: node, direction }]);
   }
   /**
@@ -2567,7 +2716,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) {
@@ -2575,12 +2725,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");
@@ -2588,12 +2738,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(
@@ -2611,12 +2762,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
@@ -2660,7 +2811,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 };
@@ -2747,9 +2898,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,
@@ -2766,17 +2921,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);
   }
@@ -2815,6 +2972,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
@@ -2889,7 +3051,9 @@ var ColumnSelector = class {
    * @returns Updated query context with DISTINCT clause
    */
   distinct(context, columns) {
-    const nodes = columns.map((col) => buildColumnNode(this.env.table, col));
+    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((col) => buildColumnNode(tableRef, col));
     const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
     const nextState = astService.withDistinct(nodes);
     return { state: nextState, hydration: context.hydration };
@@ -2946,8 +3110,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
@@ -3994,9 +4158,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);
   }
@@ -4025,6 +4210,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 col = this.env.table.columns[key];
+      if (!col) {
+        throw new Error(`Column '${key}' not found on table '${this.env.table.name}'`);
+      }
+      selection[key] = col;
+    }
+    return this.select(selection);
+  }
   /**
   
      * Selects raw column expressions
@@ -4073,6 +4273,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
@@ -4088,6 +4301,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
@@ -4185,6 +4413,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 col of cols) {
+      if (!target.columns[col]) {
+        throw new Error(
+          `Column '${col}' 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);
   }
@@ -4346,9 +4615,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));
   }
   /**
   
@@ -4359,9 +4629,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));
   }
   /**
   
@@ -4374,17 +4645,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));
   }
   /**
@@ -4398,17 +4671,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));
   }
   /**