metal-orm 1.0.17 → 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,
@@ -174,6 +175,7 @@ __export(index_exports, {
   now: () => now,
   ntile: () => ntile,
   or: () => or,
+  outerRef: () => outerRef,
   pi: () => pi,
   position: () => position,
   pow: () => pow,
@@ -279,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
    */
@@ -454,6 +480,11 @@ var toOperand = (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",
@@ -764,6 +795,45 @@ 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 _StandardFunctionStrategy {
   constructor() {
@@ -1453,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(", ");
@@ -1479,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(", ");
@@ -1511,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;
   }
@@ -1905,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;
   }
@@ -2071,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};`;
@@ -2094,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(" ");
@@ -2126,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) => {
@@ -2254,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
@@ -2746,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("(")) {
@@ -2817,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)) {
@@ -2824,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
       });
@@ -2841,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 };
   }
@@ -2877,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
@@ -2910,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]);
   }
   /**
@@ -2929,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 }]);
   }
   /**
@@ -3033,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) {
@@ -3041,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");
@@ -3054,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(
@@ -3077,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
@@ -3126,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 };
@@ -3213,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,
@@ -3232,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);
   }
@@ -3281,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
@@ -3355,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 };
@@ -3412,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
@@ -4460,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);
   }
@@ -4554,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
@@ -4569,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
@@ -4868,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));
   }
   /**
   
@@ -4881,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));
   }
   /**
   
@@ -4896,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));
   }
   /**
@@ -4920,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));
   }
   /**
@@ -6354,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("");
     }
@@ -7528,6 +7705,7 @@ function createMssqlExecutor(client) {
   columnOperand,
   concat,
   concatWs,
+  correlateBy,
   cos,
   cot,
   count,
@@ -7618,6 +7796,7 @@ function createMssqlExecutor(client) {
   now,
   ntile,
   or,
+  outerRef,
   pi,
   position,
   pow,