metal-orm 1.0.17 → 1.0.18

package/README.md

@@ -105,9 +105,10 @@ If you like explicit model classes, you can add a thin decorator layer on top of
   - `@HasMany({ target, foreignKey, ... })`
   - `@HasOne({ target, foreignKey, ... })`
   - `@BelongsTo({ target, foreignKey, ... })`
-  - `@BelongsToMany({ target, pivotTable, ... })`
-- `bootstrapEntities()` scans metadata, builds `TableDef`s, wires relations with the same `hasOne` / `hasMany` / `belongsTo` / `belongsToMany` helpers you would use manually, and returns the resulting tables.
-- `selectFromEntity(MyEntity)` lets you start a `SelectQueryBuilder` directly from the class.
+- `@BelongsToMany({ target, pivotTable, ... })`
+- `bootstrapEntities()` scans metadata, builds `TableDef`s, wires relations with the same `hasOne` / `hasMany` / `belongsTo` / `belongsToMany` helpers you would use manually, and returns the resulting tables.
+- `selectFromEntity(MyEntity)` lets you start a `SelectQueryBuilder` directly from the class.
+- **Generate entities from an existing DB**: `node scripts/generate-entities.mjs --dialect=postgres --url=$DATABASE_URL --schema=public --out=src/entities.ts` introspects your schema and spits out `@Entity` / `@Column` classes you can immediately `bootstrapEntities()` with.
 
 You don’t have to use decorators, but when you do, you’re still on the same AST + dialect + runtime foundation.
 

package/dist/decorators/index.cjs

@@ -424,6 +424,26 @@ 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 _StandardFunctionStrategy {
   constructor() {
@@ -1113,7 +1133,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(", ");
@@ -1139,7 +1159,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(", ");
@@ -1171,12 +1191,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;
   }
@@ -1565,6 +1602,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;
   }
@@ -1731,6 +1774,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};`;
@@ -1754,9 +1800,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(" ");
@@ -1786,6 +1832,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) => {
@@ -1914,6 +1975,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
@@ -2406,19 +2478,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("(")) {
@@ -2458,6 +2517,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)) {
@@ -2465,9 +2526,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
       });
@@ -2482,7 +2544,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 };
   }
@@ -2518,6 +2582,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
@@ -2551,7 +2623,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]);
   }
   /**
@@ -2570,7 +2644,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 }]);
   }
   /**
@@ -2674,7 +2750,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) {
@@ -2682,12 +2759,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");
@@ -2695,12 +2772,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(
@@ -2718,12 +2796,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
@@ -2767,7 +2845,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 };
@@ -2854,9 +2932,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,
@@ -2873,17 +2955,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);
   }
@@ -2922,6 +3006,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
@@ -2996,7 +3085,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 };
@@ -3053,8 +3144,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
@@ -4101,9 +4192,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);
   }
@@ -4195,6 +4307,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
@@ -4210,6 +4335,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
@@ -4509,9 +4649,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));
   }
   /**
   
@@ -4522,9 +4663,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));
   }
   /**
   
@@ -4537,17 +4679,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));
   }
   /**
@@ -4561,17 +4705,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));
   }
   /**