metal-orm 1.1.9 → 1.1.10

package/dist/index.js

@@ -328,7 +328,13 @@ var RelationKinds = {
   /** Many-to-one relationship */
   BelongsTo: "BELONGS_TO",
   /** Many-to-many relationship with pivot metadata */
-  BelongsToMany: "BELONGS_TO_MANY"
+  BelongsToMany: "BELONGS_TO_MANY",
+  /** Polymorphic inverse (child side) */
+  MorphTo: "MORPH_TO",
+  /** Polymorphic one-to-one (parent side) */
+  MorphOne: "MORPH_ONE",
+  /** Polymorphic one-to-many (parent side) */
+  MorphMany: "MORPH_MANY"
 };
 var hasMany = (target, foreignKey, localKey, cascade) => ({
   type: RelationKinds.HasMany,
@@ -363,6 +369,32 @@ var belongsToMany = (target, pivotTable, options) => ({
   defaultPivotColumns: options.defaultPivotColumns,
   cascade: options.cascade
 });
+var isSingleTargetRelation = (rel) => rel.type !== RelationKinds.MorphTo;
+var isMorphRelation = (rel) => rel.type === RelationKinds.MorphTo || rel.type === RelationKinds.MorphOne || rel.type === RelationKinds.MorphMany;
+var morphTo = (opts) => ({
+  type: RelationKinds.MorphTo,
+  ...opts
+});
+var morphOne = (target, opts) => ({
+  type: RelationKinds.MorphOne,
+  target,
+  morphName: opts.as,
+  typeField: opts.typeField ?? `${opts.as}Type`,
+  idField: opts.idField ?? `${opts.as}Id`,
+  typeValue: opts.typeValue,
+  localKey: opts.localKey,
+  cascade: opts.cascade
+});
+var morphMany = (target, opts) => ({
+  type: RelationKinds.MorphMany,
+  target,
+  morphName: opts.as,
+  typeField: opts.typeField ?? `${opts.as}Type`,
+  idField: opts.idField ?? `${opts.as}Id`,
+  typeValue: opts.typeValue,
+  localKey: opts.localKey,
+  cascade: opts.cascade
+});
 
 // src/core/ast/expression-nodes.ts
 var operandTypes = /* @__PURE__ */ new Set([
@@ -490,6 +522,10 @@ var or = (...operands) => ({
   operator: "OR",
   operands
 });
+var not = (operand) => ({
+  type: "NotExpression",
+  operand
+});
 var isNull = (left2) => ({
   type: "NullExpression",
   left: toOperandNode(left2),
@@ -573,6 +609,18 @@ var collate = (expression, collation) => ({
   expression: toOperand(expression),
   collation
 });
+var isDistinctFrom = (left2, right2) => ({
+  type: "IsDistinctExpression",
+  left: toOperandNode(left2),
+  operator: "IS DISTINCT FROM",
+  right: toOperand(right2)
+});
+var isNotDistinctFrom = (left2, right2) => ({
+  type: "IsDistinctExpression",
+  left: toOperandNode(left2),
+  operator: "IS NOT DISTINCT FROM",
+  right: toOperand(right2)
+});
 
 // src/core/ast/window-functions.ts
 var buildWindowFunction = (name, args = [], partitionBy, orderBy) => {
@@ -779,6 +827,9 @@ var visitExpression = (node, visitor) => {
     case "LogicalExpression":
       if (visitor.visitLogicalExpression) return visitor.visitLogicalExpression(node);
       break;
+    case "NotExpression":
+      if (visitor.visitNotExpression) return visitor.visitNotExpression(node);
+      break;
     case "NullExpression":
       if (visitor.visitNullExpression) return visitor.visitNullExpression(node);
       break;
@@ -797,6 +848,9 @@ var visitExpression = (node, visitor) => {
     case "BitwiseExpression":
       if (visitor.visitBitwiseExpression) return visitor.visitBitwiseExpression(node);
       break;
+    case "IsDistinctExpression":
+      if (visitor.visitIsDistinctExpression) return visitor.visitIsDistinctExpression(node);
+      break;
     default:
       break;
   }
@@ -1520,6 +1574,10 @@ var Dialect = class _Dialect {
       });
       return parts.join(` ${logical.operator} `);
     });
+    this.registerExpressionCompiler("NotExpression", (notExpr, ctx) => {
+      const operand = this.compileExpression(notExpr.operand, ctx);
+      return `NOT (${operand})`;
+    });
     this.registerExpressionCompiler("NullExpression", (nullExpr, ctx) => {
       const left2 = this.compileOperand(nullExpr.left, ctx);
       return `${left2} ${nullExpr.operator}`;
@@ -1553,6 +1611,11 @@ var Dialect = class _Dialect {
       const right2 = this.compileOperand(bitwise.right, ctx);
       return `${left2} ${bitwise.operator} ${right2}`;
     });
+    this.registerExpressionCompiler("IsDistinctExpression", (node, ctx) => {
+      const left2 = this.compileOperand(node.left, ctx);
+      const right2 = this.compileOperand(node.right, ctx);
+      return `${left2} ${node.operator} ${right2}`;
+    });
   }
   registerDefaultOperandCompilers() {
     this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
@@ -2474,6 +2537,18 @@ var MySqlDialect = class extends SqlDialectBase {
    */
   constructor() {
     super(new MysqlFunctionStrategy());
+    this.registerExpressionCompiler(
+      "IsDistinctExpression",
+      (node, ctx) => {
+        const left2 = this.compileOperand(node.left, ctx);
+        const right2 = this.compileOperand(node.right, ctx);
+        const spaceship = `${left2} <=> ${right2}`;
+        if (node.operator === "IS NOT DISTINCT FROM") {
+          return spaceship;
+        }
+        return `NOT (${spaceship})`;
+      }
+    );
   }
   /**
    * Quotes an identifier using MySQL backtick syntax
@@ -3573,7 +3648,7 @@ var HydrationManager = class _HydrationManager {
    */
   hasMultiplyingRelations(plan) {
     return plan.relations.some(
-      (rel) => rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany
+      (rel) => rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany || rel.type === RelationKinds.MorphMany
     );
   }
   /**
@@ -3907,6 +3982,36 @@ var HydrationPlanner = class _HydrationPlanner {
           }
         };
       }
+      case RelationKinds.MorphOne: {
+        const morphRel = rel;
+        const localKey = morphRel.localKey || findPrimaryKey(this.table);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: morphRel.target.name,
+          targetPrimaryKey: findPrimaryKey(morphRel.target),
+          foreignKey: morphRel.idField,
+          localKey,
+          columns
+        };
+      }
+      case RelationKinds.MorphMany: {
+        const morphRel = rel;
+        const localKey = morphRel.localKey || findPrimaryKey(this.table);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: morphRel.target.name,
+          targetPrimaryKey: findPrimaryKey(morphRel.target),
+          foreignKey: morphRel.idField,
+          localKey,
+          columns
+        };
+      }
+      case RelationKinds.MorphTo:
+        throw new Error("MorphTo relations do not support hydration planning via JOIN.");
     }
   }
 };
@@ -4211,23 +4316,44 @@ var assertNever = (value) => {
 };
 var baseRelationCondition = (root, relation, rootAlias, targetTableName) => {
   const rootTable = rootAlias || root.name;
+  if (relation.type === RelationKinds.MorphTo) {
+    throw new Error("MorphTo relations do not support the standard join condition builder");
+  }
   const targetTable = targetTableName ?? relation.target.name;
-  const defaultLocalKey = relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne ? findPrimaryKey(root) : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
   switch (relation.type) {
     case RelationKinds.HasMany:
-    case RelationKinds.HasOne:
+    case RelationKinds.HasOne: {
+      const defaultLocalKey = findPrimaryKey(root);
+      const localKey = relation.localKey || defaultLocalKey;
       return eq(
         { type: "Column", table: targetTable, name: relation.foreignKey },
         { type: "Column", table: rootTable, name: localKey }
       );
-    case RelationKinds.BelongsTo:
+    }
+    case RelationKinds.BelongsTo: {
+      const defaultLocalKey = findPrimaryKey(relation.target);
+      const localKey = relation.localKey || defaultLocalKey;
       return eq(
         { type: "Column", table: targetTable, name: localKey },
         { type: "Column", table: rootTable, name: relation.foreignKey }
       );
+    }
     case RelationKinds.BelongsToMany:
       throw new Error("BelongsToMany relations do not support the standard join condition builder");
+    case RelationKinds.MorphOne:
+    case RelationKinds.MorphMany: {
+      const morphRel = relation;
+      const morphLocalKey = morphRel.localKey || findPrimaryKey(root);
+      const baseCondition = eq(
+        { type: "Column", table: targetTable, name: morphRel.idField },
+        { type: "Column", table: rootTable, name: morphLocalKey }
+      );
+      const discriminatorCondition = eq(
+        { type: "Column", table: targetTable, name: morphRel.typeField },
+        { type: "Literal", value: morphRel.typeValue }
+      );
+      return and(baseCondition, discriminatorCondition);
+    }
     default:
       return assertNever(relation);
   }
@@ -4323,6 +4449,9 @@ var collectFromExpression = (expr, collector) => {
     case "LogicalExpression":
       expr.operands.forEach((operand) => collectFromExpression(operand, collector));
       break;
+    case "NotExpression":
+      collectFromExpression(expr.operand, collector);
+      break;
     case "NullExpression":
       collectFromOperand(expr.left, collector);
       break;
@@ -4429,6 +4558,11 @@ var mapExpression = (expr, fromTable, toTable) => {
       if (nextOperands.every((op, i) => op === expr.operands[i])) return expr;
       return { ...expr, operands: nextOperands };
     }
+    case "NotExpression": {
+      const operand = mapExpression(expr.operand, fromTable, toTable);
+      if (operand === expr.operand) return expr;
+      return { ...expr, operand };
+    }
     case "NullExpression": {
       const left2 = mapOperand(expr.left, fromTable, toTable);
       if (left2 === expr.left) return expr;
@@ -4729,6 +4863,9 @@ var addRelationJoin = (params) => {
     );
     return joins.reduce((curr, join) => curr.withJoin(join), state);
   }
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error("Polymorphic MorphTo relations do not support join-based strategies");
+  }
   let targetSource = tableSource ?? {
     type: "Table",
     name: relation.target.name,
@@ -4744,6 +4881,9 @@ var addRelationJoin = (params) => {
 var updateRelationJoin = (params) => {
   const { joins, joinIndex, relation, currentTable, currentAlias, options } = params;
   const join = joins[joinIndex];
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error("Polymorphic MorphTo relations do not support join updates");
+  }
   const targetName = resolveTargetTableName(join.table, relation.target.name);
   const extra = remapExpressionTable(options.filter, relation.target.name, targetName);
   if (relation.type === RelationKinds.BelongsToMany) {
@@ -4803,6 +4943,9 @@ var RelationCteBuilder = class {
     if (!predicate) {
       throw new Error("Unable to build filter CTE without predicates.");
     }
+    if (!isSingleTargetRelation(relation)) {
+      throw new Error("Polymorphic MorphTo relations do not support filter CTEs");
+    }
     const columns = Object.keys(relation.target.columns).map((name) => ({
       type: "Column",
       table: relation.target.name,
@@ -4850,6 +4993,9 @@ var buildTypedSelection = (columns, prefix, keys, missingMsg, tableOverride) =>
   }, {});
 };
 var resolveTargetColumns = (relation, options) => {
+  if (!isSingleTargetRelation(relation)) {
+    return [];
+  }
   const requestedColumns = options?.columns?.length ? [...options.columns] : Object.keys(relation.target.columns);
   const targetPrimaryKey = findPrimaryKey(relation.target);
   if (!requestedColumns.includes(targetPrimaryKey)) {
@@ -4941,11 +5087,41 @@ var belongsToManyStrategy = (context) => {
   );
   return { state, hydration };
 };
+var morphIncludeStrategy = (context) => {
+  let { state, hydration } = context;
+  const relation = context.relation;
+  const targetColumns = resolveTargetColumns(relation, context.options);
+  const tableOverride = getJoinCorrelationName(state, context.relationName, relation.target.name);
+  const targetSelection = buildTypedSelection(
+    relation.target.columns,
+    context.aliasPrefix,
+    targetColumns,
+    (key) => `Column '${key}' not found on relation '${context.relationName}'`,
+    tableOverride
+  );
+  const relationSelectionResult = context.selectColumns(state, hydration, targetSelection);
+  state = relationSelectionResult.state;
+  hydration = relationSelectionResult.hydration;
+  hydration = hydration.onRelationIncluded(
+    state,
+    relation,
+    context.relationName,
+    context.aliasPrefix,
+    targetColumns
+  );
+  return { state, hydration };
+};
+var morphToIncludeStrategy = () => {
+  throw new Error("MorphTo relations do not support JOIN-based include. Use lazy loading instead.");
+};
 var relationIncludeStrategies = {
   [RelationKinds.HasMany]: standardIncludeStrategy,
   [RelationKinds.HasOne]: standardIncludeStrategy,
   [RelationKinds.BelongsTo]: standardIncludeStrategy,
-  [RelationKinds.BelongsToMany]: belongsToManyStrategy
+  [RelationKinds.BelongsToMany]: belongsToManyStrategy,
+  [RelationKinds.MorphOne]: morphIncludeStrategy,
+  [RelationKinds.MorphMany]: morphIncludeStrategy,
+  [RelationKinds.MorphTo]: morphToIncludeStrategy
 };
 
 // src/query-builder/relation-service.ts
@@ -5014,6 +5190,12 @@ var RelationService = class {
     let state = this.state;
     let hydration = this.hydration;
     const relation = this.getRelation(relationName);
+    if (relation.type === RelationKinds.MorphTo) {
+      throw new Error(`MorphTo relation '${relationName}' does not support include() via JOIN. Use lazy loading ($load) instead.`);
+    }
+    if (!isSingleTargetRelation(relation)) {
+      return { state, hydration };
+    }
     const aliasPrefix = options?.aliasPrefix ?? relationName;
     const alreadyJoined = hasJoinForRelationKey(state.ast.joins, relationName);
     const { selfFilters, crossFilters } = splitFilterExpressions(
@@ -5072,6 +5254,9 @@ var RelationService = class {
    */
   applyRelationCorrelation(relationName, ast, additionalCorrelation) {
     const relation = this.getRelation(relationName);
+    if (relation.type === RelationKinds.MorphTo) {
+      throw new Error(`MorphTo relation '${relationName}' does not support correlation-based operations.`);
+    }
     const rootAlias = this.state.ast.from.type === "Table" ? this.state.ast.from.alias : void 0;
     let correlation = buildRelationCorrelation(this.table, relation, rootAlias);
     if (additionalCorrelation) {
@@ -5531,6 +5716,45 @@ var populateHydrationCache = (entity, row, meta) => {
       }
     }
   }
+  for (const relationName of Object.keys(meta.table.relations)) {
+    const relation = meta.table.relations[relationName];
+    const data = row[relationName];
+    if (relation.type === RelationKinds.MorphOne) {
+      const localKey = relation.localKey || findPrimaryKey(meta.table);
+      const rootValue = entity[localKey];
+      if (rootValue === void 0 || rootValue === null) continue;
+      if (!data || typeof data !== "object") continue;
+      const cache = /* @__PURE__ */ new Map();
+      cache.set(toKey2(rootValue), data);
+      meta.relationHydration.set(relationName, cache);
+      meta.relationCache.set(relationName, Promise.resolve(cache));
+      continue;
+    }
+    if (relation.type === RelationKinds.MorphMany) {
+      if (!Array.isArray(data)) continue;
+      const localKey = relation.localKey || findPrimaryKey(meta.table);
+      const rootValue = entity[localKey];
+      if (rootValue === void 0 || rootValue === null) continue;
+      const cache = /* @__PURE__ */ new Map();
+      cache.set(toKey2(rootValue), data);
+      meta.relationHydration.set(relationName, cache);
+      meta.relationCache.set(relationName, Promise.resolve(cache));
+      continue;
+    }
+    if (relation.type === RelationKinds.MorphTo) {
+      if (!data || typeof data !== "object") continue;
+      const morphTo2 = relation;
+      const typeValue = entity[morphTo2.typeField];
+      const idValue = entity[morphTo2.idField];
+      if (!typeValue || idValue === void 0 || idValue === null) continue;
+      const compositeKey = `${toKey2(typeValue)}:${toKey2(idValue)}`;
+      const cache = /* @__PURE__ */ new Map();
+      cache.set(compositeKey, data);
+      meta.relationHydration.set(relationName, cache);
+      meta.relationCache.set(relationName, Promise.resolve(cache));
+      continue;
+    }
+  }
 };
 
 // src/orm/relations/has-many.ts
@@ -6203,113 +6427,519 @@ var DefaultManyToManyCollection = class {
   }
 };
 
-// src/orm/lazy-batch/shared.ts
-var hasColumns = (columns) => Boolean(columns && columns.length > 0);
-var buildColumnSelection = (table, columns, missingMsg) => {
-  return columns.reduce((acc, column) => {
-    const def = table.columns[column];
-    if (!def) {
-      throw new Error(missingMsg(column));
-    }
-    acc[column] = def;
-    return acc;
-  }, {});
-};
-var filterRow = (row, columns) => {
-  const filtered = {};
-  for (const column of columns) {
-    if (column in row) {
-      filtered[column] = row[column];
-    }
-  }
-  return filtered;
-};
-var filterRows = (rows, columns) => rows.map((row) => filterRow(row, columns));
-var rowsFromResults = (results) => {
-  const rows = [];
-  for (const result of results) {
-    const { columns, values } = result;
-    for (const valueRow of values) {
-      const row = {};
-      columns.forEach((column, idx) => {
-        row[column] = valueRow[idx];
-      });
-      rows.push(row);
-    }
-  }
-  return rows;
-};
-var executeQuery = async (ctx, qb) => {
-  const compiled = ctx.dialect.compileSelect(qb.getAST());
-  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
-  return rowsFromResults(results);
-};
+// src/orm/relations/morph-one.ts
 var toKey7 = (value) => value === null || value === void 0 ? "" : String(value);
-var collectKeysFromRoots = (roots, key) => {
-  const collected = /* @__PURE__ */ new Set();
-  for (const tracked of roots) {
-    const value = tracked.entity[key];
-    if (value !== null && value !== void 0) {
-      collected.add(value);
-    }
+var hideInternal5 = (obj, keys) => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
   }
-  return collected;
 };
-var buildInListValues = (keys) => Array.from(keys);
-var fetchRowsForKeys = async (ctx, table, column, keys, selection, filter) => {
-  let qb = new SelectQueryBuilder(table).select(selection);
-  qb = qb.where(inList(column, buildInListValues(keys)));
-  if (filter) {
-    qb = qb.where(filter);
+var hideWritable5 = (obj, keys) => {
+  for (const key of keys) {
+    const value = obj[key];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
   }
-  return executeQuery(ctx, qb);
 };
-var groupRowsByMany = (rows, keyColumn) => {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const value = row[keyColumn];
-    if (value === null || value === void 0) continue;
-    const key = toKey7(value);
-    const bucket = grouped.get(key) ?? [];
-    bucket.push(row);
-    grouped.set(key, bucket);
+var DefaultMorphOneReference = class {
+  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
+    this.ctx = ctx;
+    this.meta = meta;
+    this.root = root;
+    this.relationName = relationName;
+    this.relation = relation;
+    this.rootTable = rootTable;
+    this.loader = loader;
+    this.createEntity = createEntity;
+    this.localKey = localKey;
+    hideInternal5(this, [
+      "ctx",
+      "meta",
+      "root",
+      "relationName",
+      "relation",
+      "rootTable",
+      "loader",
+      "createEntity",
+      "localKey"
+    ]);
+    hideWritable5(this, ["loaded", "current"]);
+    this.populateFromHydrationCache();
   }
-  return grouped;
-};
-var groupRowsByUnique = (rows, keyColumn) => {
-  const lookup = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const value = row[keyColumn];
-    if (value === null || value === void 0) continue;
-    const key = toKey7(value);
-    if (!lookup.has(key)) {
-      lookup.set(key, row);
+  loaded = false;
+  current = null;
+  async load() {
+    if (this.loaded) return this.current;
+    const map = await this.loader();
+    const keyValue = this.root[this.localKey];
+    if (keyValue === void 0 || keyValue === null) {
+      this.loaded = true;
+      return this.current;
     }
+    const row = map.get(toKey7(keyValue));
+    this.current = row ? this.createEntity(row) : null;
+    this.loaded = true;
+    return this.current;
   }
-  return lookup;
-};
-
-// src/orm/lazy-batch/has-many.ts
-var loadHasManyRelation = async (ctx, rootTable, relationName, relation, options) => {
-  const localKey = relation.localKey || findPrimaryKey(rootTable);
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const keys = collectKeysFromRoots(roots, localKey);
-  if (!keys.size) {
-    return /* @__PURE__ */ new Map();
-  }
-  const fkColumn = relation.target.columns[relation.foreignKey];
-  if (!fkColumn) return /* @__PURE__ */ new Map();
-  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
-  const targetPrimaryKey = findPrimaryKey(relation.target);
-  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
-  if (!selectedColumns.includes(targetPrimaryKey)) {
-    selectedColumns.push(targetPrimaryKey);
+  get() {
+    return this.current;
   }
-  const queryColumns = new Set(selectedColumns);
-  queryColumns.add(relation.foreignKey);
-  const selection = buildColumnSelection(
-    relation.target,
-    Array.from(queryColumns),
+  set(data) {
+    if (data === null) {
+      return this.detachCurrent();
+    }
+    const entity = hasEntityMeta(data) ? data : this.createEntity(data);
+    if (this.current && this.current !== entity) {
+      this.ctx.registerRelationChange(
+        this.root,
+        this.relationKey,
+        this.rootTable,
+        this.relationName,
+        this.relation,
+        { kind: "remove", entity: this.current }
+      );
+    }
+    this.assignMorphKeys(entity);
+    this.current = entity;
+    this.loaded = true;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "attach", entity }
+    );
+    return entity;
+  }
+  toJSON() {
+    if (!this.current) return null;
+    const entityWithToJSON = this.current;
+    return typeof entityWithToJSON.toJSON === "function" ? entityWithToJSON.toJSON() : this.current;
+  }
+  detachCurrent() {
+    const previous = this.current;
+    if (!previous) return null;
+    this.current = null;
+    this.loaded = true;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "remove", entity: previous }
+    );
+    return null;
+  }
+  assignMorphKeys(entity) {
+    const keyValue = this.root[this.localKey];
+    entity[this.relation.idField] = keyValue;
+    entity[this.relation.typeField] = this.relation.typeValue;
+  }
+  get relationKey() {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+  populateFromHydrationCache() {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === void 0 || keyValue === null) return;
+    const row = getHydrationRecord(this.meta, this.relationName, keyValue);
+    if (!row) return;
+    this.current = this.createEntity(row);
+    this.loaded = true;
+  }
+};
+
+// src/orm/relations/morph-many.ts
+var toKey8 = (value) => value === null || value === void 0 ? "" : String(value);
+var hideInternal6 = (obj, keys) => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+var hideWritable6 = (obj, keys) => {
+  for (const key of keys) {
+    const value = obj[key];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+};
+var DefaultMorphManyCollection = class {
+  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, localKey) {
+    this.ctx = ctx;
+    this.meta = meta;
+    this.root = root;
+    this.relationName = relationName;
+    this.relation = relation;
+    this.rootTable = rootTable;
+    this.loader = loader;
+    this.createEntity = createEntity;
+    this.localKey = localKey;
+    hideInternal6(this, ["ctx", "meta", "root", "relationName", "relation", "rootTable", "loader", "createEntity", "localKey"]);
+    hideWritable6(this, ["loaded", "items", "added", "removed"]);
+    this.hydrateFromCache();
+  }
+  loaded = false;
+  items = [];
+  added = /* @__PURE__ */ new Set();
+  removed = /* @__PURE__ */ new Set();
+  async load() {
+    if (this.loaded) return this.items;
+    const map = await this.loader();
+    const key = toKey8(this.root[this.localKey]);
+    const rows = map.get(key) ?? [];
+    this.items = rows.map((row) => this.createEntity(row));
+    this.loaded = true;
+    return this.items;
+  }
+  getItems() {
+    return this.items;
+  }
+  get length() {
+    return this.items.length;
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  add(data) {
+    const keyValue = this.root[this.localKey];
+    const childRow = {
+      ...data,
+      [this.relation.idField]: keyValue,
+      [this.relation.typeField]: this.relation.typeValue
+    };
+    const entity = this.createEntity(childRow);
+    this.added.add(entity);
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "add", entity }
+    );
+    return entity;
+  }
+  attach(entity) {
+    const keyValue = this.root[this.localKey];
+    entity[this.relation.idField] = keyValue;
+    entity[this.relation.typeField] = this.relation.typeValue;
+    this.ctx.markDirty(entity);
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "attach", entity }
+    );
+  }
+  remove(entity) {
+    this.items = this.items.filter((item) => item !== entity);
+    this.removed.add(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "remove", entity }
+    );
+  }
+  clear() {
+    for (const entity of [...this.items]) {
+      this.remove(entity);
+    }
+  }
+  get relationKey() {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+  hydrateFromCache() {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === void 0 || keyValue === null) return;
+    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
+    if (!rows?.length) return;
+    this.items = rows.map((row) => this.createEntity(row));
+    this.loaded = true;
+  }
+  toJSON() {
+    return this.items.map((item) => {
+      const entityWithToJSON = item;
+      return typeof entityWithToJSON.toJSON === "function" ? entityWithToJSON.toJSON() : item;
+    });
+  }
+};
+
+// src/orm/relations/morph-to.ts
+var toKey9 = (value) => value === null || value === void 0 ? "" : String(value);
+var hideInternal7 = (obj, keys) => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+var hideWritable7 = (obj, keys) => {
+  for (const key of keys) {
+    const value = obj[key];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+};
+var DefaultMorphToReference = class {
+  constructor(ctx, meta, root, relationName, relation, rootTable, loader, createEntity, resolveTargetTable) {
+    this.ctx = ctx;
+    this.meta = meta;
+    this.root = root;
+    this.relationName = relationName;
+    this.relation = relation;
+    this.rootTable = rootTable;
+    this.loader = loader;
+    this.createEntity = createEntity;
+    this.resolveTargetTable = resolveTargetTable;
+    hideInternal7(this, [
+      "ctx",
+      "meta",
+      "root",
+      "relationName",
+      "relation",
+      "rootTable",
+      "loader",
+      "createEntity",
+      "resolveTargetTable"
+    ]);
+    hideWritable7(this, ["loaded", "current"]);
+    this.populateFromHydrationCache();
+  }
+  loaded = false;
+  current = null;
+  async load() {
+    if (this.loaded) return this.current;
+    const rootObj = this.root;
+    const typeValue = rootObj[this.relation.typeField];
+    const idValue = rootObj[this.relation.idField];
+    if (!typeValue || idValue === void 0 || idValue === null) {
+      this.loaded = true;
+      return this.current;
+    }
+    const map = await this.loader();
+    const compositeKey = `${toKey9(typeValue)}:${toKey9(idValue)}`;
+    const row = map.get(compositeKey);
+    if (row) {
+      const targetTable = this.resolveTargetTable(toKey9(typeValue));
+      if (targetTable) {
+        this.current = this.createEntity(targetTable, row);
+      }
+    }
+    this.loaded = true;
+    return this.current;
+  }
+  get() {
+    return this.current;
+  }
+  set(data) {
+    if (data === null) {
+      return this.detachCurrent();
+    }
+    const entity = hasEntityMeta(data) ? data : data;
+    if (this.current && this.current !== entity) {
+      this.ctx.registerRelationChange(
+        this.root,
+        this.relationKey,
+        this.rootTable,
+        this.relationName,
+        this.relation,
+        { kind: "remove", entity: this.current }
+      );
+    }
+    this.current = entity;
+    this.loaded = true;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "attach", entity }
+    );
+    return entity;
+  }
+  toJSON() {
+    if (!this.current) return null;
+    const entityWithToJSON = this.current;
+    return typeof entityWithToJSON.toJSON === "function" ? entityWithToJSON.toJSON() : this.current;
+  }
+  detachCurrent() {
+    const previous = this.current;
+    if (!previous) return null;
+    this.current = null;
+    this.loaded = true;
+    const rootObj = this.root;
+    rootObj[this.relation.typeField] = null;
+    rootObj[this.relation.idField] = null;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: "remove", entity: previous }
+    );
+    return null;
+  }
+  get relationKey() {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+  populateFromHydrationCache() {
+    const rootObj = this.root;
+    const typeValue = rootObj[this.relation.typeField];
+    const idValue = rootObj[this.relation.idField];
+    if (!typeValue || idValue === void 0 || idValue === null) return;
+    const compositeKey = `${toKey9(typeValue)}:${toKey9(idValue)}`;
+    const row = getHydrationRecord(this.meta, this.relationName, compositeKey);
+    if (!row) return;
+    const targetTable = this.resolveTargetTable(toKey9(typeValue));
+    if (targetTable) {
+      this.current = this.createEntity(targetTable, row);
+      this.loaded = true;
+    }
+  }
+};
+
+// src/orm/lazy-batch/shared.ts
+var hasColumns = (columns) => Boolean(columns && columns.length > 0);
+var buildColumnSelection = (table, columns, missingMsg) => {
+  return columns.reduce((acc, column) => {
+    const def = table.columns[column];
+    if (!def) {
+      throw new Error(missingMsg(column));
+    }
+    acc[column] = def;
+    return acc;
+  }, {});
+};
+var filterRow = (row, columns) => {
+  const filtered = {};
+  for (const column of columns) {
+    if (column in row) {
+      filtered[column] = row[column];
+    }
+  }
+  return filtered;
+};
+var filterRows = (rows, columns) => rows.map((row) => filterRow(row, columns));
+var rowsFromResults = (results) => {
+  const rows = [];
+  for (const result of results) {
+    const { columns, values } = result;
+    for (const valueRow of values) {
+      const row = {};
+      columns.forEach((column, idx) => {
+        row[column] = valueRow[idx];
+      });
+      rows.push(row);
+    }
+  }
+  return rows;
+};
+var executeQuery = async (ctx, qb) => {
+  const compiled = ctx.dialect.compileSelect(qb.getAST());
+  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
+  return rowsFromResults(results);
+};
+var toKey10 = (value) => value === null || value === void 0 ? "" : String(value);
+var collectKeysFromRoots = (roots, key) => {
+  const collected = /* @__PURE__ */ new Set();
+  for (const tracked of roots) {
+    const value = tracked.entity[key];
+    if (value !== null && value !== void 0) {
+      collected.add(value);
+    }
+  }
+  return collected;
+};
+var buildInListValues = (keys) => Array.from(keys);
+var fetchRowsForKeys = async (ctx, table, column, keys, selection, filter) => {
+  let qb = new SelectQueryBuilder(table).select(selection);
+  qb = qb.where(inList(column, buildInListValues(keys)));
+  if (filter) {
+    qb = qb.where(filter);
+  }
+  return executeQuery(ctx, qb);
+};
+var groupRowsByMany = (rows, keyColumn) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const value = row[keyColumn];
+    if (value === null || value === void 0) continue;
+    const key = toKey10(value);
+    const bucket = grouped.get(key) ?? [];
+    bucket.push(row);
+    grouped.set(key, bucket);
+  }
+  return grouped;
+};
+var groupRowsByUnique = (rows, keyColumn) => {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const value = row[keyColumn];
+    if (value === null || value === void 0) continue;
+    const key = toKey10(value);
+    if (!lookup.has(key)) {
+      lookup.set(key, row);
+    }
+  }
+  return lookup;
+};
+
+// src/orm/lazy-batch/has-many.ts
+var loadHasManyRelation = async (ctx, rootTable, relationName, relation, options) => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = collectKeysFromRoots(roots, localKey);
+  if (!keys.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const fkColumn = relation.target.columns[relation.foreignKey];
+  if (!fkColumn) return /* @__PURE__ */ new Map();
+  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.foreignKey);
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
     (column) => `Column '${column}' not found on relation '${relationName}'`
   );
   const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, options?.filter);
@@ -6466,12 +7096,12 @@ var loadBelongsToManyRelation = async (ctx, rootTable, relationName, relation, o
     if (rootValue === null || rootValue === void 0 || targetValue === null || targetValue === void 0) {
       continue;
     }
-    const bucket = rootLookup.get(toKey7(rootValue)) ?? [];
+    const bucket = rootLookup.get(toKey10(rootValue)) ?? [];
     bucket.push({
       targetId: targetValue,
       pivot: pivotVisibleColumns.size ? filterRow(pivot, pivotVisibleColumns) : {}
     });
-    rootLookup.set(toKey7(rootValue), bucket);
+    rootLookup.set(toKey10(rootValue), bucket);
     targetIds.add(targetValue);
   }
   if (!targetIds.size) {
@@ -6501,27 +7131,144 @@ var loadBelongsToManyRelation = async (ctx, rootTable, relationName, relation, o
   const targetMap = groupRowsByUnique(targetRows, targetKey);
   const targetVisibleColumns = new Set(targetSelectedColumns);
   const result = /* @__PURE__ */ new Map();
-  for (const [rootId, entries] of rootLookup.entries()) {
-    const bucket = [];
-    for (const entry of entries) {
-      const targetRow = targetMap.get(toKey7(entry.targetId));
-      if (!targetRow) continue;
-      const row = targetRequestedColumns ? filterRow(targetRow, targetVisibleColumns) : { ...targetRow };
-      if (options?.pivot?.merge) {
-        mergePivotIntoRow(row, entry.pivot);
-      }
-      bucket.push({ ...row, _pivot: entry.pivot });
+  for (const [rootId, entries] of rootLookup.entries()) {
+    const bucket = [];
+    for (const entry of entries) {
+      const targetRow = targetMap.get(toKey10(entry.targetId));
+      if (!targetRow) continue;
+      const row = targetRequestedColumns ? filterRow(targetRow, targetVisibleColumns) : { ...targetRow };
+      if (options?.pivot?.merge) {
+        mergePivotIntoRow(row, entry.pivot);
+      }
+      bucket.push({ ...row, _pivot: entry.pivot });
+    }
+    result.set(rootId, bucket);
+  }
+  return result;
+};
+var mergePivotIntoRow = (row, pivot) => {
+  for (const [key, value] of Object.entries(pivot)) {
+    if (key in row) continue;
+    row[key] = value;
+  }
+};
+
+// src/orm/lazy-batch/morph-one.ts
+var loadMorphOneRelation = async (ctx, rootTable, relationName, relation, options) => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = collectKeysFromRoots(roots, localKey);
+  if (!keys.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const fkColumn = relation.target.columns[relation.idField];
+  if (!fkColumn) return /* @__PURE__ */ new Map();
+  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.idField);
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
+    (column) => `Column '${column}' not found on relation '${relationName}'`
+  );
+  const typeColumn = relation.target.columns[relation.typeField];
+  const discriminatorFilter = eq(
+    typeColumn ?? { type: "Column", table: relation.target.name, name: relation.typeField },
+    { type: "Literal", value: relation.typeValue }
+  );
+  const combinedFilter = options?.filter ? and(options.filter, discriminatorFilter) : discriminatorFilter;
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, combinedFilter);
+  const grouped = groupRowsByUnique(rows, relation.idField);
+  if (!requestedColumns) return grouped;
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [key, row] of grouped.entries()) {
+    filtered.set(key, filterRow(row, visibleColumns));
+  }
+  return filtered;
+};
+
+// src/orm/lazy-batch/morph-many.ts
+var loadMorphManyRelation = async (ctx, rootTable, relationName, relation, options) => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = collectKeysFromRoots(roots, localKey);
+  if (!keys.size) {
+    return /* @__PURE__ */ new Map();
+  }
+  const fkColumn = relation.target.columns[relation.idField];
+  if (!fkColumn) return /* @__PURE__ */ new Map();
+  const requestedColumns = hasColumns(options?.columns) ? [...options.columns] : void 0;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.idField);
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
+    (column) => `Column '${column}' not found on relation '${relationName}'`
+  );
+  const typeColumn = relation.target.columns[relation.typeField];
+  const discriminatorFilter = eq(
+    typeColumn ?? { type: "Column", table: relation.target.name, name: relation.typeField },
+    { type: "Literal", value: relation.typeValue }
+  );
+  const combinedFilter = options?.filter ? and(options.filter, discriminatorFilter) : discriminatorFilter;
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, combinedFilter);
+  const grouped = groupRowsByMany(rows, relation.idField);
+  if (!requestedColumns) return grouped;
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [key, bucket] of grouped.entries()) {
+    filtered.set(key, filterRows(bucket, visibleColumns));
+  }
+  return filtered;
+};
+
+// src/orm/lazy-batch/morph-to.ts
+var loadMorphToRelation = async (ctx, rootTable, _relationName, relation) => {
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const result = /* @__PURE__ */ new Map();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const tracked of roots) {
+    const entity = tracked.entity;
+    const typeValue = entity[relation.typeField];
+    const idValue = entity[relation.idField];
+    if (!typeValue || idValue === void 0 || idValue === null) continue;
+    const typeKey = toKey10(typeValue);
+    const ids = grouped.get(typeKey) ?? /* @__PURE__ */ new Set();
+    ids.add(idValue);
+    grouped.set(typeKey, ids);
+  }
+  for (const [typeKey, ids] of grouped.entries()) {
+    const targetTable = relation.targets[typeKey];
+    if (!targetTable) continue;
+    const targetPk = relation.targetKey || findPrimaryKey(targetTable);
+    const pkColumn = targetTable.columns[targetPk];
+    if (!pkColumn) continue;
+    const selection = buildColumnSelection(
+      targetTable,
+      Object.keys(targetTable.columns),
+      (column) => `Column '${column}' not found on target '${targetTable.name}'`
+    );
+    const rows = await fetchRowsForKeys(ctx, targetTable, pkColumn, ids, selection);
+    for (const row of rows) {
+      const pkValue = row[targetPk];
+      if (pkValue === void 0 || pkValue === null) continue;
+      const compositeKey = `${typeKey}:${toKey10(pkValue)}`;
+      result.set(compositeKey, row);
     }
-    result.set(rootId, bucket);
   }
   return result;
 };
-var mergePivotIntoRow = (row, pivot) => {
-  for (const [key, value] of Object.entries(pivot)) {
-    if (key in row) continue;
-    row[key] = value;
-  }
-};
 
 // src/orm/entity-relation-cache.ts
 var relationLoaderCache = (meta, relationName, factory) => {
@@ -6688,6 +7435,60 @@ var instantiateWrapper = (meta, relationName, relation, owner, createEntity) =>
         localKey
       );
     }
+    case RelationKinds.MorphOne: {
+      const morphOne2 = relation;
+      const localKey = morphOne2.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(
+        () => loadMorphOneRelation(meta.ctx, meta.table, relationName, morphOne2, resolveOptions())
+      );
+      return new DefaultMorphOneReference(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        morphOne2,
+        meta.table,
+        loader,
+        (row) => createEntity(morphOne2.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.MorphMany: {
+      const morphMany2 = relation;
+      const localKey = morphMany2.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(
+        () => loadMorphManyRelation(meta.ctx, meta.table, relationName, morphMany2, resolveOptions())
+      );
+      return new DefaultMorphManyCollection(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        morphMany2,
+        meta.table,
+        loader,
+        (row) => createEntity(morphMany2.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.MorphTo: {
+      const morphTo2 = relation;
+      const loader = () => loadCached(
+        () => loadMorphToRelation(meta.ctx, meta.table, relationName, morphTo2)
+      );
+      const resolveTargetTable = (typeValue) => morphTo2.targets[typeValue];
+      return new DefaultMorphToReference(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        morphTo2,
+        meta.table,
+        loader,
+        (table, row) => createEntity(table, row),
+        resolveTargetTable
+      );
+    }
     default:
       return void 0;
   }
@@ -6713,7 +7514,7 @@ var createEntityProxy = (ctx, table, row, lazyRelations = [], lazyRelationOption
   const isCollectionRelation = (relationName) => {
     const rel = table.relations[relationName];
     if (!rel) return false;
-    return rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany;
+    return rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany || rel.type === RelationKinds.MorphMany;
   };
   const buildJson = (self, options) => {
     const json = {};
@@ -6895,9 +7696,11 @@ function rowsToQueryResult(rows) {
 }
 function createExecutorFromQueryRunner(runner) {
   const supportsTransactions = typeof runner.beginTransaction === "function" && typeof runner.commitTransaction === "function" && typeof runner.rollbackTransaction === "function";
+  const supportsSavepoints = supportsTransactions && typeof runner.savepoint === "function" && typeof runner.releaseSavepoint === "function" && typeof runner.rollbackToSavepoint === "function";
   return {
     capabilities: {
-      transactions: supportsTransactions
+      transactions: supportsTransactions,
+      ...supportsSavepoints ? { savepoints: true } : {}
     },
     async executeSql(sql, params) {
       const rows = await runner.query(sql, params);
@@ -6922,6 +7725,24 @@ function createExecutorFromQueryRunner(runner) {
       }
       await runner.rollbackTransaction.call(runner);
     },
+    async savepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      await runner.savepoint.call(runner, name);
+    },
+    async releaseSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      await runner.releaseSavepoint.call(runner, name);
+    },
+    async rollbackToSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      await runner.rollbackToSavepoint.call(runner, name);
+    },
     async dispose() {
       await runner.dispose?.call(runner);
     }
@@ -7296,6 +8117,9 @@ function buildWhereHasPredicate(env, context, relationFacet, createChildBuilder,
   }
   const callback = typeof callbackOrOptions === "function" ? callbackOrOptions : void 0;
   const options = typeof callbackOrOptions === "function" ? maybeOptions : callbackOrOptions;
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error(`Polymorphic relation '${relationName}' does not support whereHas/whereHasNot`);
+  }
   let subQb = createChildBuilder(relation.target);
   if (callback) {
     subQb = callback(subQb);
@@ -8882,6 +9706,7 @@ var isTableDef = (value) => {
 
 // src/decorators/decorator-metadata.ts
 var METADATA_KEY = "metal-orm:decorators";
+var LEGACY_METADATA_KEY = /* @__PURE__ */ Symbol.for("metal-orm:decorators:legacy");
 var getOrCreateMetadataBag = (context) => {
   const metadata = context.metadata || (context.metadata = {});
   let bag = metadata[METADATA_KEY];
@@ -8891,16 +9716,65 @@ var getOrCreateMetadataBag = (context) => {
   }
   return bag;
 };
+var getOrCreateMetadataBagOnConstructor = (ctor) => {
+  const carrier = ctor;
+  let bag = carrier[LEGACY_METADATA_KEY];
+  if (!bag) {
+    bag = { columns: [], relations: [], transformers: [] };
+    carrier[LEGACY_METADATA_KEY] = bag;
+  }
+  return bag;
+};
 var readMetadataBag = (context) => {
   return context.metadata?.[METADATA_KEY];
 };
 var readMetadataBagFromConstructor = (ctor) => {
   const metadataSymbol = Symbol.metadata;
-  if (!metadataSymbol) return void 0;
-  const metadata = Reflect.get(ctor, metadataSymbol);
-  return metadata?.[METADATA_KEY];
+  if (metadataSymbol) {
+    const metadata = Reflect.get(ctor, metadataSymbol);
+    const stage3Bag = metadata?.[METADATA_KEY];
+    if (stage3Bag) {
+      return stage3Bag;
+    }
+  }
+  return ctor[LEGACY_METADATA_KEY];
 };
 var getDecoratorMetadata = (ctor) => readMetadataBagFromConstructor(ctor);
+var normalizePropertyName = (name) => {
+  if (typeof name === "symbol") {
+    return name.description ?? name.toString();
+  }
+  return name;
+};
+var isStage3FieldContext = (value) => {
+  return typeof value === "object" && value !== null && "name" in value && "private" in value && "metadata" in value;
+};
+var resolveFieldDecoratorInfo = (targetOrValue, contextOrProperty, decoratorName) => {
+  if (isStage3FieldContext(contextOrProperty)) {
+    if (!contextOrProperty.name) {
+      throw new Error(`${decoratorName} decorator requires a property name`);
+    }
+    if (contextOrProperty.private) {
+      throw new Error(`${decoratorName} decorator does not support private fields`);
+    }
+    return {
+      propertyName: normalizePropertyName(contextOrProperty.name),
+      bag: getOrCreateMetadataBag(contextOrProperty)
+    };
+  }
+  if (typeof contextOrProperty === "string" || typeof contextOrProperty === "symbol") {
+    const legacyTarget = targetOrValue;
+    const ctor = typeof legacyTarget === "function" ? legacyTarget : legacyTarget?.constructor;
+    if (!ctor || typeof ctor !== "function" && typeof ctor !== "object") {
+      throw new Error(`${decoratorName} decorator requires a class field target`);
+    }
+    return {
+      propertyName: normalizePropertyName(contextOrProperty),
+      bag: getOrCreateMetadataBagOnConstructor(ctor)
+    };
+  }
+  throw new Error(`${decoratorName} decorator received an unsupported decorator context`);
+};
 
 // src/decorators/bootstrap.ts
 var unwrapTarget = (target) => {
@@ -8990,6 +9864,48 @@ var buildRelationDefinitions = (meta, tableMap) => {
         );
         break;
       }
+      case RelationKinds.MorphOne: {
+        relations[name] = morphOne(
+          resolveTableTarget(relation.target, tableMap),
+          {
+            as: relation.morphName,
+            typeValue: relation.typeValue,
+            typeField: relation.typeField,
+            idField: relation.idField,
+            localKey: relation.localKey,
+            cascade: relation.cascade
+          }
+        );
+        break;
+      }
+      case RelationKinds.MorphMany: {
+        relations[name] = morphMany(
+          resolveTableTarget(relation.target, tableMap),
+          {
+            as: relation.morphName,
+            typeValue: relation.typeValue,
+            typeField: relation.typeField,
+            idField: relation.idField,
+            localKey: relation.localKey,
+            cascade: relation.cascade
+          }
+        );
+        break;
+      }
+      case RelationKinds.MorphTo: {
+        const resolvedTargets = {};
+        for (const [typeValue, targetResolver] of Object.entries(relation.targets)) {
+          resolvedTargets[typeValue] = resolveTableTarget(targetResolver, tableMap);
+        }
+        relations[name] = morphTo({
+          typeField: relation.typeField,
+          idField: relation.idField,
+          targets: resolvedTargets,
+          targetKey: relation.targetKey,
+          cascade: relation.cascade
+        });
+        break;
+      }
     }
   }
   return relations;
@@ -9063,6 +9979,45 @@ var resolveSingleRelation = (relationName, relation, rootMeta) => {
         }
       );
     }
+    case RelationKinds.MorphOne: {
+      return morphOne(
+        resolveTableTarget(relation.target, tableMap),
+        {
+          as: relation.morphName,
+          typeValue: relation.typeValue,
+          typeField: relation.typeField,
+          idField: relation.idField,
+          localKey: relation.localKey,
+          cascade: relation.cascade
+        }
+      );
+    }
+    case RelationKinds.MorphMany: {
+      return morphMany(
+        resolveTableTarget(relation.target, tableMap),
+        {
+          as: relation.morphName,
+          typeValue: relation.typeValue,
+          typeField: relation.typeField,
+          idField: relation.idField,
+          localKey: relation.localKey,
+          cascade: relation.cascade
+        }
+      );
+    }
+    case RelationKinds.MorphTo: {
+      const resolvedTargets = {};
+      for (const [typeValue, targetResolver] of Object.entries(relation.targets)) {
+        resolvedTargets[typeValue] = resolveTableTarget(targetResolver, tableMap);
+      }
+      return morphTo({
+        typeField: relation.typeField,
+        idField: relation.idField,
+        targets: resolvedTargets,
+        targetKey: relation.targetKey,
+        cascade: relation.cascade
+      });
+    }
     default:
       throw new Error(`Unknown relation kind for relation '${relationName}'`);
   }
@@ -12652,6 +13607,9 @@ var TypeScriptGenerator = class {
   visitLogicalExpression(logical) {
     return this.printLogicalExpression(logical);
   }
+  visitNotExpression(notExpr) {
+    return this.printNotExpression(notExpr);
+  }
   visitNullExpression(nullExpr) {
     return this.printNullExpression(nullExpr);
   }
@@ -12727,6 +13685,9 @@ var TypeScriptGenerator = class {
     ${parts.join(",\n    ")}
   )`;
   }
+  printNotExpression(notExpr) {
+    return `not(${this.printExpression(notExpr.operand)})`;
+  }
   printArithmeticExpression(expr) {
     const left2 = this.printOperand(expr.left);
     const right2 = this.printOperand(expr.right);
@@ -13420,6 +14381,15 @@ var RelationChangeProcessor = class {
         case RelationKinds.BelongsTo:
           await this.handleBelongsToChange(entry);
           break;
+        case RelationKinds.MorphOne:
+          await this.handleMorphOneChange(entry);
+          break;
+        case RelationKinds.MorphMany:
+          await this.handleMorphManyChange(entry);
+          break;
+        case RelationKinds.MorphTo:
+          await this.handleMorphToChange(entry);
+          break;
       }
     }
   }
@@ -13622,6 +14592,86 @@ var RelationChangeProcessor = class {
     }
     return Object.keys(payload).length ? payload : void 0;
   }
+  async handleMorphOneChange(entry) {
+    const relation = entry.relation;
+    const target = entry.change.entity;
+    if (!target) return;
+    const tracked = this.unitOfWork.findTracked(target);
+    if (!tracked) return;
+    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootValue = entry.root[localKey];
+    if (rootValue === void 0 || rootValue === null) return;
+    if (entry.change.kind === "add" || entry.change.kind === "attach") {
+      const child = tracked.entity;
+      child[relation.idField] = rootValue;
+      child[relation.typeField] = relation.typeValue;
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+    if (entry.change.kind === "remove") {
+      const child = tracked.entity;
+      if (relation.cascade === "all" || relation.cascade === "remove") {
+        this.unitOfWork.markRemoved(child);
+        return;
+      }
+      child[relation.idField] = null;
+      child[relation.typeField] = null;
+      this.unitOfWork.markDirty(child);
+    }
+  }
+  async handleMorphManyChange(entry) {
+    const relation = entry.relation;
+    const target = entry.change.entity;
+    if (!target) return;
+    const tracked = this.unitOfWork.findTracked(target);
+    if (!tracked) return;
+    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootValue = entry.root[localKey];
+    if (rootValue === void 0 || rootValue === null) return;
+    if (entry.change.kind === "add" || entry.change.kind === "attach") {
+      const child = tracked.entity;
+      child[relation.idField] = rootValue;
+      child[relation.typeField] = relation.typeValue;
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+    if (entry.change.kind === "remove") {
+      const child = tracked.entity;
+      if (relation.cascade === "all" || relation.cascade === "remove") {
+        this.unitOfWork.markRemoved(child);
+        return;
+      }
+      child[relation.idField] = null;
+      child[relation.typeField] = null;
+      this.unitOfWork.markDirty(child);
+    }
+  }
+  async handleMorphToChange(entry) {
+    const relation = entry.relation;
+    const target = entry.change.entity;
+    if (!target) return;
+    if (entry.change.kind === "attach" || entry.change.kind === "add") {
+      const targetEntity = target;
+      for (const [typeValue, targetTable] of Object.entries(relation.targets)) {
+        const targetPk = relation.targetKey || findPrimaryKey(targetTable);
+        const pkValue = targetEntity[targetPk];
+        if (pkValue !== void 0 && pkValue !== null) {
+          const rootEntity = entry.root;
+          rootEntity[relation.typeField] = typeValue;
+          rootEntity[relation.idField] = pkValue;
+          this.unitOfWork.markDirty(entry.root);
+          break;
+        }
+      }
+      return;
+    }
+    if (entry.change.kind === "remove") {
+      const rootEntity = entry.root;
+      rootEntity[relation.typeField] = null;
+      rootEntity[relation.idField] = null;
+      this.unitOfWork.markDirty(entry.root);
+    }
+  }
 };
 
 // src/orm/query-logger.ts
@@ -13638,6 +14688,9 @@ var createQueryLoggingExecutor = (executor, logger) => {
     beginTransaction: () => executor.beginTransaction(),
     commitTransaction: () => executor.commitTransaction(),
     rollbackTransaction: () => executor.rollbackTransaction(),
+    savepoint: executor.savepoint ? (name) => executor.savepoint(name) : void 0,
+    releaseSavepoint: executor.releaseSavepoint ? (name) => executor.releaseSavepoint(name) : void 0,
+    rollbackToSavepoint: executor.rollbackToSavepoint ? (name) => executor.rollbackToSavepoint(name) : void 0,
     dispose: () => executor.dispose()
   };
   return wrapped;
@@ -13660,7 +14713,7 @@ var runInTransaction = async (executor, action) => {
 };
 
 // src/orm/save-graph.ts
-var toKey8 = (value) => value === null || value === void 0 ? "" : String(value);
+var toKey11 = (value) => value === null || value === void 0 ? "" : String(value);
 var coerceColumnValue = (table, columnName, value, options) => {
   if (value === null || value === void 0) return value;
   const column = table.columns[columnName];
@@ -13722,11 +14775,11 @@ var isEntityInCollection = (items, pkName, entity) => {
   if (items.includes(entity)) return true;
   const entityPk = entity[pkName];
   if (entityPk === void 0 || entityPk === null) return false;
-  return items.some((item) => toKey8(item[pkName]) === toKey8(entityPk));
+  return items.some((item) => toKey11(item[pkName]) === toKey11(entityPk));
 };
 var findInCollectionByPk = (items, pkName, pkValue) => {
   if (pkValue === void 0 || pkValue === null) return void 0;
-  return items.find((item) => toKey8(item[pkName]) === toKey8(pkValue));
+  return items.find((item) => toKey11(item[pkName]) === toKey11(pkValue));
 };
 var extractPivotPayload = (payload) => {
   const pivot = payload._pivot ?? payload.pivot;
@@ -13755,13 +14808,13 @@ var handleHasMany = async (session, root, relationName, relation, payload, optio
       collection.attach(entity);
     }
     if (pkValue !== void 0 && pkValue !== null) {
-      seen.add(toKey8(pkValue));
+      seen.add(toKey11(pkValue));
     }
   }
   if (options.pruneMissing) {
     for (const item of [...collection.getItems()]) {
       const pkValue = item[targetPk];
-      if (pkValue !== void 0 && pkValue !== null && !seen.has(toKey8(pkValue))) {
+      if (pkValue !== void 0 && pkValue !== null && !seen.has(toKey11(pkValue))) {
         collection.remove(item);
       }
     }
@@ -13819,7 +14872,7 @@ var handleBelongsToMany = async (session, root, relationName, relation, payload,
     if (typeof item === "number" || typeof item === "string") {
       const id = item;
       collection.attach(id);
-      seen.add(toKey8(id));
+      seen.add(toKey11(id));
       continue;
     }
     const asObj = item;
@@ -13837,18 +14890,89 @@ var handleBelongsToMany = async (session, root, relationName, relation, payload,
       collection.attach(entity, pivotPayload);
     }
     if (pkValue !== void 0 && pkValue !== null) {
-      seen.add(toKey8(pkValue));
+      seen.add(toKey11(pkValue));
     }
   }
   if (options.pruneMissing) {
     for (const item of [...collection.getItems()]) {
       const pkValue = item[targetPk];
-      if (pkValue !== void 0 && pkValue !== null && !seen.has(toKey8(pkValue))) {
+      if (pkValue !== void 0 && pkValue !== null && !seen.has(toKey11(pkValue))) {
         collection.detach(item);
       }
     }
   }
 };
+var handleMorphOne = async (session, root, relationName, relation, payload, options) => {
+  const ref = root[relationName];
+  if (payload === void 0) return;
+  if (payload === null) {
+    ref.set(null);
+    return;
+  }
+  const pk = findPrimaryKey(relation.target);
+  if (typeof payload === "number" || typeof payload === "string") {
+    const entity = ref.set({ [pk]: payload });
+    if (entity) {
+      await applyGraphToEntity(session, relation.target, entity, { [pk]: payload }, options);
+    }
+    return;
+  }
+  const attached = ref.set(payload);
+  if (attached) {
+    await applyGraphToEntity(session, relation.target, attached, payload, options);
+  }
+};
+var handleMorphMany = async (session, root, relationName, relation, payload, options) => {
+  if (!Array.isArray(payload)) return;
+  const collection = root[relationName];
+  await collection.load();
+  const targetTable = relation.target;
+  const targetPk = findPrimaryKey(targetTable);
+  const existing = collection.getItems();
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of payload) {
+    if (item === null || item === void 0) continue;
+    const asObj = typeof item === "object" ? item : { [targetPk]: item };
+    const pkValue = asObj[targetPk];
+    const current = findInCollectionByPk(existing, targetPk, pkValue) ?? (pkValue !== void 0 && pkValue !== null ? session.getEntity(targetTable, pkValue) : void 0);
+    const entity = current ?? ensureEntity(session, targetTable, asObj, options);
+    assignColumns(targetTable, entity, asObj, options);
+    await applyGraphToEntity(session, targetTable, entity, asObj, options);
+    if (!isEntityInCollection(collection.getItems(), targetPk, entity)) {
+      collection.attach(entity);
+    }
+    if (pkValue !== void 0 && pkValue !== null) {
+      seen.add(toKey11(pkValue));
+    }
+  }
+  if (options.pruneMissing) {
+    for (const item of [...collection.getItems()]) {
+      const pkValue = item[targetPk];
+      if (pkValue !== void 0 && pkValue !== null && !seen.has(toKey11(pkValue))) {
+        collection.remove(item);
+      }
+    }
+  }
+};
+var handleMorphTo = async (session, root, relationName, relation, payload, options) => {
+  const ref = root[relationName];
+  if (payload === void 0) return;
+  if (payload === null) {
+    ref.set(null);
+    return;
+  }
+  const attached = ref.set(payload);
+  if (attached) {
+    for (const [, targetTable] of Object.entries(relation.targets)) {
+      const pk = relation.targetKey || findPrimaryKey(targetTable);
+      const pkValue = attached[pk];
+      if (pkValue !== void 0 && pkValue !== null) {
+        await applyGraphToEntity(session, targetTable, attached, payload, options);
+        break;
+      }
+    }
+  }
+};
 var applyRelation = async (session, table, entity, relationName, relation, payload, options) => {
   switch (relation.type) {
     case RelationKinds.HasMany:
@@ -13859,6 +14983,12 @@ var applyRelation = async (session, table, entity, relationName, relation, paylo
       return handleBelongsTo(session, entity, relationName, relation, payload, options);
     case RelationKinds.BelongsToMany:
       return handleBelongsToMany(session, entity, relationName, relation, payload, options);
+    case RelationKinds.MorphOne:
+      return handleMorphOne(session, entity, relationName, relation, payload, options);
+    case RelationKinds.MorphMany:
+      return handleMorphMany(session, entity, relationName, relation, payload, options);
+    case RelationKinds.MorphTo:
+      return handleMorphTo(session, entity, relationName, relation, payload, options);
   }
 };
 var applyGraphToEntity = async (session, table, entity, payload, options) => {
@@ -13887,6 +15017,8 @@ var patchGraphInternal = async (session, entityClass, existing, payload, options
 };
 
 // src/orm/orm-session.ts
+var NESTED_TRANSACTIONS_REQUIRE_SAVEPOINTS = "Nested session.transaction calls require savepoint support in this executor";
+var ROLLBACK_ONLY_TRANSACTION = "Cannot commit transaction because an inner transaction failed";
 var OrmSession = class {
   /** The ORM instance */
   orm;
@@ -13906,6 +15038,9 @@ var OrmSession = class {
   tenantId;
   interceptors;
   saveGraphDefaults;
+  transactionDepth = 0;
+  savepointCounter = 0;
+  rollbackOnly = false;
   /**
    * Creates a new OrmSession instance.
    * @param opts - Session options
@@ -14248,16 +15383,43 @@ var OrmSession = class {
       await this.commit();
       return result;
     }
-    await this.executor.beginTransaction();
+    const isOutermost = this.transactionDepth === 0;
+    let savepointName = null;
+    if (isOutermost) {
+      this.rollbackOnly = false;
+      await this.executor.beginTransaction();
+    } else {
+      this.assertSavepointSupport();
+      savepointName = this.nextSavepointName();
+      await this.executor.savepoint(savepointName);
+    }
+    this.transactionDepth += 1;
     try {
       const result = await fn8(this);
+      this.throwIfRollbackOnly();
       await this.flushWithHooks();
-      await this.executor.commitTransaction();
-      await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
+      this.throwIfRollbackOnly();
+      if (isOutermost) {
+        await this.executor.commitTransaction();
+        await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
+      } else {
+        await this.executor.releaseSavepoint(savepointName);
+      }
       return result;
     } catch (err) {
-      await this.rollback();
+      if (isOutermost) {
+        await this.rollback();
+      } else {
+        this.rollbackOnly = true;
+        await this.executor.rollbackToSavepoint(savepointName);
+      }
       throw err;
+    } finally {
+      this.transactionDepth = Math.max(0, this.transactionDepth - 1);
+      if (this.transactionDepth === 0) {
+        this.rollbackOnly = false;
+        this.savepointCounter = 0;
+      }
     }
   }
   /**
@@ -14267,6 +15429,9 @@ var OrmSession = class {
     if (this.executor.capabilities.transactions) {
       await this.executor.rollbackTransaction();
     }
+    this.transactionDepth = 0;
+    this.savepointCounter = 0;
+    this.rollbackOnly = false;
     this.unitOfWork.reset();
     this.relationChanges.reset();
   }
@@ -14341,6 +15506,23 @@ var OrmSession = class {
   resolveSaveGraphOptions(options) {
     return { ...this.saveGraphDefaults ?? {}, ...options ?? {} };
   }
+  assertSavepointSupport() {
+    if (!this.executor.capabilities.savepoints) {
+      throw new Error(NESTED_TRANSACTIONS_REQUIRE_SAVEPOINTS);
+    }
+    if (typeof this.executor.savepoint !== "function" || typeof this.executor.releaseSavepoint !== "function" || typeof this.executor.rollbackToSavepoint !== "function") {
+      throw new Error(NESTED_TRANSACTIONS_REQUIRE_SAVEPOINTS);
+    }
+  }
+  nextSavepointName() {
+    this.savepointCounter += 1;
+    return `metalorm_sp_${this.savepointCounter}`;
+  }
+  throwIfRollbackOnly() {
+    if (this.rollbackOnly) {
+      throw new Error(ROLLBACK_ONLY_TRANSACTION);
+    }
+  }
 };
 var buildRelationChangeEntry = (root, relationKey, rootTable, relationName, relation, change) => ({
   root,
@@ -14865,7 +16047,7 @@ var TREE_METADATA_KEY = /* @__PURE__ */ Symbol("metal-orm:tree");
 function Tree(options = {}) {
   return function(target, context) {
     const config = resolveTreeConfig(options);
-    const metadataBag = readMetadataBag(context) ?? readMetadataBagFromConstructor(target);
+    const metadataBag = context ? readMetadataBag(context) ?? readMetadataBagFromConstructor(target) : readMetadataBagFromConstructor(target);
     const metadata = {
       config,
       parentProperty: metadataBag?.tree?.parentProperty,
@@ -14877,28 +16059,22 @@ function Tree(options = {}) {
   };
 }
 function TreeParent() {
-  return function(_value, context) {
-    if (!context.name) {
-      throw new Error("TreeParent decorator requires a property name");
-    }
-    if (context.private) {
-      throw new Error("TreeParent decorator does not support private fields");
-    }
-    const propertyName = String(context.name);
-    const bag = getOrCreateMetadataBag(context);
+  return function(targetOrValue, contextOrProperty) {
+    const { propertyName, bag } = resolveFieldDecoratorInfo(
+      targetOrValue,
+      contextOrProperty,
+      "TreeParent"
+    );
     bag.tree = { ...bag.tree, parentProperty: propertyName };
   };
 }
 function TreeChildren() {
-  return function(_value, context) {
-    if (!context.name) {
-      throw new Error("TreeChildren decorator requires a property name");
-    }
-    if (context.private) {
-      throw new Error("TreeChildren decorator does not support private fields");
-    }
-    const propertyName = String(context.name);
-    const bag = getOrCreateMetadataBag(context);
+  return function(targetOrValue, contextOrProperty) {
+    const { propertyName, bag } = resolveFieldDecoratorInfo(
+      targetOrValue,
+      contextOrProperty,
+      "TreeChildren"
+    );
     bag.tree = { ...bag.tree, childrenProperty: propertyName };
   };
 }
@@ -15062,7 +16238,7 @@ function Entity(options = {}) {
     const ctor = value;
     const tableName = options.tableName ?? deriveTableNameFromConstructor(ctor);
     setEntityTableName(ctor, tableName, options.hooks, options.type);
-    const bag = readMetadataBag(context);
+    const bag = context ? readMetadataBag(context) : readMetadataBagFromConstructor(ctor);
     if (bag) {
       const meta = ensureEntityMetadata(ctor);
       for (const entry of bag.columns) {
@@ -15116,29 +16292,20 @@ var normalizeColumnInput = (input) => {
   }
   return column;
 };
-var normalizePropertyName = (name) => {
-  if (typeof name === "symbol") {
-    return name.description ?? name.toString();
-  }
-  return name;
-};
-var registerColumnFromContext = (context, column) => {
-  if (!context.name) {
-    throw new Error("Column decorator requires a property name");
-  }
-  if (context.private) {
-    throw new Error("Column decorator does not support private fields");
-  }
-  const propertyName = normalizePropertyName(context.name);
-  const bag = getOrCreateMetadataBag(context);
+var registerColumnFromContext = (targetOrValue, contextOrProperty, column) => {
+  const { propertyName, bag } = resolveFieldDecoratorInfo(
+    targetOrValue,
+    contextOrProperty,
+    "Column"
+  );
   if (!bag.columns.some((entry) => entry.propertyName === propertyName)) {
     bag.columns.push({ propertyName, column: { ...column } });
   }
 };
 function Column(definition) {
   const normalized = normalizeColumnInput(definition);
-  return function(_value, context) {
-    registerColumnFromContext(context, normalized);
+  return function(targetOrValue, contextOrProperty) {
+    registerColumnFromContext(targetOrValue, contextOrProperty, normalized);
   };
 }
 function PrimaryKey(definition) {
@@ -15148,22 +16315,13 @@ function PrimaryKey(definition) {
 }
 
 // src/decorators/relations.ts
-var normalizePropertyName2 = (name) => {
-  if (typeof name === "symbol") {
-    return name.description ?? name.toString();
-  }
-  return name;
-};
 var createFieldDecorator = (metadataFactory) => {
-  return function(_value, context) {
-    if (!context.name) {
-      throw new Error("Relation decorator requires a property name");
-    }
-    if (context.private) {
-      throw new Error("Relation decorator does not support private fields");
-    }
-    const propertyName = normalizePropertyName2(context.name);
-    const bag = getOrCreateMetadataBag(context);
+  return function(targetOrValue, contextOrProperty) {
+    const { propertyName, bag } = resolveFieldDecoratorInfo(
+      targetOrValue,
+      contextOrProperty,
+      "Relation"
+    );
     const relationMetadata = metadataFactory(propertyName);
     if (!bag.relations.some((entry) => entry.propertyName === propertyName)) {
       bag.relations.push({ propertyName, relation: relationMetadata });
@@ -15215,6 +16373,43 @@ function BelongsToMany(options) {
     cascade: options.cascade
   }));
 }
+function MorphTo(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.MorphTo,
+    propertyKey: propertyName,
+    typeField: options.typeField,
+    idField: options.idField,
+    targets: options.targets,
+    targetKey: options.targetKey,
+    cascade: options.cascade
+  }));
+}
+function MorphOne(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.MorphOne,
+    propertyKey: propertyName,
+    target: options.target,
+    morphName: options.morphName,
+    typeValue: options.typeValue,
+    typeField: options.typeField,
+    idField: options.idField,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
+function MorphMany(options) {
+  return createFieldDecorator((propertyName) => ({
+    kind: RelationKinds.MorphMany,
+    propertyKey: propertyName,
+    target: options.target,
+    morphName: options.morphName,
+    typeValue: options.typeValue,
+    typeField: options.typeField,
+    idField: options.idField,
+    localKey: options.localKey,
+    cascade: options.cascade
+  }));
+}
 
 // src/decorators/transformers/built-in/string-transformers.ts
 var TrimTransformer = class {
@@ -15400,15 +16595,12 @@ var PatternValidator = class {
 };
 
 // src/decorators/transformers/transformer-decorators.ts
-var normalizePropertyName3 = (name) => {
-  if (typeof name === "symbol") {
-    return name.description ?? name.toString();
-  }
-  return name;
-};
-var registerTransformerMetadata = (context, metadata) => {
-  const propertyName = normalizePropertyName3(context.name);
-  const bag = getOrCreateMetadataBag(context);
+var registerTransformerMetadata = (targetOrValue, contextOrProperty, metadata) => {
+  const { propertyName, bag } = resolveFieldDecoratorInfo(
+    targetOrValue,
+    contextOrProperty,
+    "Transformer"
+  );
   let existing = bag.transformers.find((t) => t.propertyName === propertyName);
   if (!existing) {
     existing = {
@@ -15437,64 +16629,64 @@ var registerTransformerMetadata = (context, metadata) => {
   }
 };
 function Trim(options) {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       sanitizers: [new TrimTransformer(options)]
     });
   };
 }
 function Lower() {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       sanitizers: [new CaseTransformer("lower")]
     });
   };
 }
 function Upper() {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       sanitizers: [new CaseTransformer("upper")]
     });
   };
 }
 function Capitalize() {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       sanitizers: [new CaseTransformer("capitalize")]
     });
   };
 }
 function Title() {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       sanitizers: [new CaseTransformer("title")]
     });
   };
 }
 function Alphanumeric(options) {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       validators: [new AlphanumericValidator(options)]
     });
   };
 }
 function Email(options) {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       validators: [new EmailValidator(options)]
     });
   };
 }
 function Length(options) {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       validators: [new LengthValidator(options)]
     });
   };
 }
 function Pattern(options) {
-  return function(_value, context) {
-    registerTransformerMetadata(context, {
+  return function(targetOrValue, contextOrProperty) {
+    registerTransformerMetadata(targetOrValue, contextOrProperty, {
       validators: [new PatternValidator(options)]
     });
   };
@@ -15721,16 +16913,12 @@ var CEPValidator = class {
 registerValidator("BR", "cpf", () => new CPFValidator());
 registerValidator("BR", "cnpj", () => new CNPJValidator());
 registerValidator("BR", "cep", () => new CEPValidator());
-var normalizePropertyName4 = (name) => {
-  if (typeof name === "symbol") {
-    return name.description ?? name.toString();
-  }
-  return name;
+var resolveCountryDecoratorInfo = (targetOrValue, contextOrProperty) => {
+  return resolveFieldDecoratorInfo(targetOrValue, contextOrProperty, "Country validator");
 };
 function CPF(options) {
-  return function(_value, context) {
-    const propertyName = normalizePropertyName4(context.name);
-    const bag = getOrCreateMetadataBag(context);
+  return function(targetOrValue, contextOrProperty) {
+    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
     let existing = bag.transformers.find((t) => t.propertyName === propertyName);
     if (!existing) {
       existing = {
@@ -15778,9 +16966,8 @@ function CPF(options) {
   };
 }
 function CNPJ(options) {
-  return function(_value, context) {
-    const propertyName = normalizePropertyName4(context.name);
-    const bag = getOrCreateMetadataBag(context);
+  return function(targetOrValue, contextOrProperty) {
+    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
     let existing = bag.transformers.find((t) => t.propertyName === propertyName);
     if (!existing) {
       existing = {
@@ -15828,9 +17015,8 @@ function CNPJ(options) {
   };
 }
 function CEP(options) {
-  return function(_value, context) {
-    const propertyName = normalizePropertyName4(context.name);
-    const bag = getOrCreateMetadataBag(context);
+  return function(targetOrValue, contextOrProperty) {
+    const { propertyName, bag } = resolveCountryDecoratorInfo(targetOrValue, contextOrProperty);
     let existing = bag.transformers.find((t) => t.propertyName === propertyName);
     if (!existing) {
       existing = {
@@ -16086,6 +17272,14 @@ var Pool = class {
 };
 
 // src/core/execution/executors/postgres-executor.ts
+var SAVEPOINT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var sanitizeSavepointName = (name) => {
+  const trimmed = name.trim();
+  if (!SAVEPOINT_NAME_PATTERN.test(trimmed)) {
+    throw new Error(`Invalid savepoint name: "${name}"`);
+  }
+  return trimmed;
+};
 function createPostgresExecutor(client) {
   return createExecutorFromQueryRunner({
     async query(sql, params) {
@@ -16100,11 +17294,24 @@ function createPostgresExecutor(client) {
     },
     async rollbackTransaction() {
       await client.query("ROLLBACK");
+    },
+    async savepoint(name) {
+      const savepoint = sanitizeSavepointName(name);
+      await client.query(`SAVEPOINT ${savepoint}`);
+    },
+    async releaseSavepoint(name) {
+      const savepoint = sanitizeSavepointName(name);
+      await client.query(`RELEASE SAVEPOINT ${savepoint}`);
+    },
+    async rollbackToSavepoint(name) {
+      const savepoint = sanitizeSavepointName(name);
+      await client.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
     }
   });
 }
 
 // src/core/execution/executors/mysql-executor.ts
+var SAVEPOINT_NAME_PATTERN2 = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var isRowObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isRowObjectArray = (value) => Array.isArray(value) && value.every(isRowObject);
 var isMysqlResultHeader = (value) => isRowObject(value) && ("affectedRows" in value || "insertId" in value || "warningStatus" in value || "serverStatus" in value);
@@ -16116,6 +17323,13 @@ var headerToQueryResult = (header) => ({
     rowsAffected: header.affectedRows
   }
 });
+var sanitizeSavepointName2 = (name) => {
+  const trimmed = name.trim();
+  if (!SAVEPOINT_NAME_PATTERN2.test(trimmed)) {
+    throw new Error(`Invalid savepoint name: "${name}"`);
+  }
+  return trimmed;
+};
 var normalizeMysqlResults = (rows) => {
   if (!Array.isArray(rows)) {
     return isMysqlResultHeader(rows) ? [headerToQueryResult(rows)] : [rowsToQueryResult([])];
@@ -16137,9 +17351,11 @@ var normalizeMysqlResults = (rows) => {
 };
 function createMysqlExecutor(client) {
   const supportsTransactions = typeof client.beginTransaction === "function" && typeof client.commit === "function" && typeof client.rollback === "function";
+  const supportsSavepoints = supportsTransactions;
   return {
     capabilities: {
-      transactions: supportsTransactions
+      transactions: supportsTransactions,
+      ...supportsSavepoints ? { savepoints: true } : {}
     },
     async executeSql(sql, params) {
       const [rows] = await client.query(sql, params);
@@ -16163,17 +17379,55 @@ function createMysqlExecutor(client) {
       }
       await client.rollback();
     },
+    async savepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName2(name);
+      await client.query(`SAVEPOINT ${savepoint}`);
+    },
+    async releaseSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName2(name);
+      await client.query(`RELEASE SAVEPOINT ${savepoint}`);
+    },
+    async rollbackToSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName2(name);
+      await client.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+    },
     async dispose() {
     }
   };
 }
 
 // src/core/execution/executors/sqlite-executor.ts
+var SAVEPOINT_NAME_PATTERN3 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var sanitizeSavepointName3 = (name) => {
+  const trimmed = name.trim();
+  if (!SAVEPOINT_NAME_PATTERN3.test(trimmed)) {
+    throw new Error(`Invalid savepoint name: "${name}"`);
+  }
+  return trimmed;
+};
 function createSqliteExecutor(client) {
   const supportsTransactions = typeof client.beginTransaction === "function" && typeof client.commitTransaction === "function" && typeof client.rollbackTransaction === "function";
+  const supportsSavepoints = supportsTransactions;
+  const executeControlStatement = async (sql) => {
+    if (typeof client.run === "function") {
+      await client.run(sql);
+      return;
+    }
+    await client.all(sql);
+  };
   return {
     capabilities: {
-      transactions: supportsTransactions
+      transactions: supportsTransactions,
+      ...supportsSavepoints ? { savepoints: true } : {}
     },
     async executeSql(sql, params) {
       const rows = await client.all(sql, params);
@@ -16198,17 +17452,120 @@ function createSqliteExecutor(client) {
       }
       await client.rollbackTransaction();
     },
+    async savepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName3(name);
+      if (typeof client.savepoint === "function") {
+        await client.savepoint(savepoint);
+        return;
+      }
+      await executeControlStatement(`SAVEPOINT ${savepoint}`);
+    },
+    async releaseSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName3(name);
+      if (typeof client.releaseSavepoint === "function") {
+        await client.releaseSavepoint(savepoint);
+        return;
+      }
+      await executeControlStatement(`RELEASE SAVEPOINT ${savepoint}`);
+    },
+    async rollbackToSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName3(name);
+      if (typeof client.rollbackToSavepoint === "function") {
+        await client.rollbackToSavepoint(savepoint);
+        return;
+      }
+      await executeControlStatement(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+    },
+    async dispose() {
+    }
+  };
+}
+
+// src/core/execution/executors/better-sqlite3-executor.ts
+var SAVEPOINT_NAME_PATTERN4 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var sanitizeSavepointName4 = (name) => {
+  const trimmed = name.trim();
+  if (!SAVEPOINT_NAME_PATTERN4.test(trimmed)) {
+    throw new Error(`Invalid savepoint name: "${name}"`);
+  }
+  return trimmed;
+};
+function createBetterSqlite3Executor(client) {
+  return {
+    capabilities: {
+      transactions: true,
+      savepoints: true
+    },
+    async executeSql(sql, params) {
+      const stmt = client.prepare(sql);
+      let result;
+      if (stmt.reader) {
+        const rows = stmt.all(...params ?? []);
+        result = rowsToQueryResult(rows);
+      } else {
+        const info = stmt.run(...params ?? []);
+        result = {
+          columns: [],
+          values: [],
+          meta: {
+            rowsAffected: info.changes,
+            insertId: typeof info.lastInsertRowid === "bigint" ? info.lastInsertRowid.toString() : info.lastInsertRowid
+          }
+        };
+      }
+      return toExecutionPayload([result]);
+    },
+    async beginTransaction() {
+      client.prepare("BEGIN").run();
+    },
+    async commitTransaction() {
+      client.prepare("COMMIT").run();
+    },
+    async rollbackTransaction() {
+      client.prepare("ROLLBACK").run();
+    },
+    async savepoint(name) {
+      const savepoint = sanitizeSavepointName4(name);
+      client.prepare(`SAVEPOINT ${savepoint}`).run();
+    },
+    async releaseSavepoint(name) {
+      const savepoint = sanitizeSavepointName4(name);
+      client.prepare(`RELEASE SAVEPOINT ${savepoint}`).run();
+    },
+    async rollbackToSavepoint(name) {
+      const savepoint = sanitizeSavepointName4(name);
+      client.prepare(`ROLLBACK TO SAVEPOINT ${savepoint}`).run();
+    },
     async dispose() {
     }
   };
 }
 
 // src/core/execution/executors/mssql-executor.ts
+var SAVEPOINT_NAME_PATTERN5 = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var sanitizeSavepointName5 = (name) => {
+  const trimmed = name.trim();
+  if (!SAVEPOINT_NAME_PATTERN5.test(trimmed)) {
+    throw new Error(`Invalid savepoint name: "${name}"`);
+  }
+  return trimmed;
+};
 function createMssqlExecutor(client) {
   const supportsTransactions = typeof client.beginTransaction === "function" && typeof client.commit === "function" && typeof client.rollback === "function";
+  const supportsSavepoints = supportsTransactions;
   return {
     capabilities: {
-      transactions: supportsTransactions
+      transactions: supportsTransactions,
+      ...supportsSavepoints ? { savepoints: true } : {}
     },
     async executeSql(sql, params) {
       const { recordset, recordsets } = await client.query(sql, params);
@@ -16233,6 +17590,25 @@ function createMssqlExecutor(client) {
       }
       await client.rollback();
     },
+    async savepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName5(name);
+      await client.query(`SAVE TRANSACTION ${savepoint}`);
+    },
+    async releaseSavepoint(_name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+    },
+    async rollbackToSavepoint(name) {
+      if (!supportsSavepoints) {
+        throw new Error("Savepoints are not supported by this executor");
+      }
+      const savepoint = sanitizeSavepointName5(name);
+      await client.query(`ROLLBACK TRANSACTION ${savepoint}`);
+    },
     async dispose() {
     }
   };
@@ -16308,6 +17684,7 @@ var isQueryResult = (value) => typeof value === "object" && value !== null && Ar
 var isRowArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "object" && item !== null && !Array.isArray(item));
 function createPooledExecutorFactory(opts) {
   const { pool, adapter } = opts;
+  const supportsSavepoints = typeof adapter.savepoint === "function" && typeof adapter.releaseSavepoint === "function" && typeof adapter.rollbackToSavepoint === "function";
   const makeExecutor = (mode) => {
     let lease = null;
     const getLease = async () => {
@@ -16325,8 +17702,17 @@ function createPooledExecutorFactory(opts) {
       }
       return toExecutionPayload([rowsToQueryResult(rows)]);
     };
+    const requireActiveTransactionLease = () => {
+      if (!lease) {
+        throw new Error("savepoint operation called without an active transaction");
+      }
+      return lease;
+    };
     return {
-      capabilities: { transactions: true },
+      capabilities: {
+        transactions: true,
+        ...supportsSavepoints ? { savepoints: true } : {}
+      },
       async executeSql(sql, params) {
         if (mode === "sticky") {
           const l2 = await getLease();
@@ -16370,6 +17756,27 @@ function createPooledExecutorFactory(opts) {
           await l.release();
         }
       },
+      async savepoint(name) {
+        if (!supportsSavepoints) {
+          throw new Error("Savepoints are not supported by this executor");
+        }
+        const l = requireActiveTransactionLease();
+        await adapter.savepoint(l.resource, name);
+      },
+      async releaseSavepoint(name) {
+        if (!supportsSavepoints) {
+          throw new Error("Savepoints are not supported by this executor");
+        }
+        const l = requireActiveTransactionLease();
+        await adapter.releaseSavepoint(l.resource, name);
+      },
+      async rollbackToSavepoint(name) {
+        if (!supportsSavepoints) {
+          throw new Error("Savepoints are not supported by this executor");
+        }
+        const l = requireActiveTransactionLease();
+        await adapter.rollbackToSavepoint(l.resource, name);
+      },
       async dispose() {
         if (!lease) return;
         const l = lease;
@@ -16464,6 +17871,9 @@ var updateInclude = (qb, relationPath, updater) => {
         filter: segmentOptions?.filter
       });
     }
+    if (!isSingleTargetRelation(relation)) {
+      continue;
+    }
     const joinForSegment = findJoinByRelationKey(state.ast.joins, relationKey);
     currentAlias = joinForSegment ? getExposedName(joinForSegment.table) ?? relation.target.name : relation.target.name;
     currentTable = relation.target;
@@ -16592,6 +18002,9 @@ function applyRelationFilter(qb, table, relationName, filter) {
       `Relation filter "${relationName}" must include at least one of "some", "none", "every", "isEmpty", or "isNotEmpty".`
     );
   }
+  if (!isSingleTargetRelation(relation)) {
+    return qb;
+  }
   if (filter.some) {
     const predicate = buildFilterExpression(relation.target, filter.some);
     if (predicate) {
@@ -16637,6 +18050,9 @@ function applyRelationFilter(qb, table, relationName, filter) {
   return qb;
 }
 var buildRelationSubqueryBase = (table, relation) => {
+  if (!isSingleTargetRelation(relation)) {
+    throw new Error("MorphTo relations do not support subquery-based filtering");
+  }
   const target = relation.target;
   if (relation.type === RelationKinds.BelongsToMany) {
     const many = relation;
@@ -16682,7 +18098,14 @@ var buildRelationSubqueryBase = (table, relation) => {
     schema: target.schema
   };
   const correlation = buildRelationCorrelation(table, relation);
-  const groupByColumnName = relation.type === RelationKinds.BelongsTo ? relation.localKey || findPrimaryKey(target) : relation.foreignKey;
+  let groupByColumnName;
+  if (relation.type === RelationKinds.BelongsTo) {
+    groupByColumnName = relation.localKey || findPrimaryKey(target);
+  } else if (relation.type === RelationKinds.MorphOne || relation.type === RelationKinds.MorphMany) {
+    groupByColumnName = relation.idField;
+  } else {
+    groupByColumnName = relation.foreignKey;
+  }
   return {
     from,
     joins: [],
@@ -16714,6 +18137,9 @@ function buildRelationFilterExpression(table, relationName, filter) {
       where
     };
   };
+  if (!isSingleTargetRelation(relation)) {
+    return null;
+  }
   if (filter.some) {
     const predicate = buildFilterExpression(relation.target, filter.some);
     if (predicate) {
@@ -19683,6 +21109,432 @@ var TagIndex = class {
     };
   }
 };
+
+// src/bulk/bulk-context.ts
+function createBulkExecutionContext(session) {
+  const executionContext = session.getExecutionContext();
+  return {
+    session,
+    executionContext,
+    dialect: executionContext.dialect,
+    supportsReturning: executionContext.dialect.supportsDmlReturningClause()
+  };
+}
+async function executeCompiled(ctx, compiled) {
+  const payload = await ctx.executionContext.interceptors.run(
+    { sql: compiled.sql, params: compiled.params },
+    ctx.executionContext.executor
+  );
+  return extractResultSets(payload);
+}
+function extractResultSets(payload) {
+  const result = payload;
+  if (result.resultSets) {
+    return result.resultSets;
+  }
+  return [];
+}
+function flattenQueryResults(resultSets) {
+  const rows = [];
+  for (const rs of resultSets) {
+    for (const valueRow of rs.values) {
+      const obj = {};
+      rs.columns.forEach((col2, idx) => {
+        const bare = col2.split(".").pop().replace(/^["`[\]]+|["`[\]]+$/g, "");
+        obj[bare] = valueRow[idx];
+      });
+      rows.push(obj);
+    }
+  }
+  return rows;
+}
+function resolveReturningColumns(ctx, table, returning) {
+  if (!returning) return void 0;
+  if (!ctx.supportsReturning) return void 0;
+  if (returning === true) {
+    return Object.values(table.columns).map((col2) => ({
+      type: "Column",
+      table: table.name,
+      name: col2.name,
+      alias: col2.name
+    }));
+  }
+  return returning.map((col2) => ({
+    type: "Column",
+    table: table.name,
+    name: col2.name,
+    alias: col2.name
+  }));
+}
+
+// src/bulk/bulk-utils.ts
+function splitIntoChunks(items, size) {
+  if (size < 1) throw new RangeError(`chunkSize must be >= 1, got ${size}`);
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+async function runWithConcurrency(tasks, concurrency) {
+  const limit = concurrency === "sequential" ? 1 : Math.max(1, concurrency);
+  if (limit === 1) {
+    const results2 = [];
+    for (const task of tasks) {
+      results2.push(await task());
+    }
+    return results2;
+  }
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < tasks.length) {
+      const i = nextIndex++;
+      results[i] = await tasks[i]();
+    }
+  };
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, worker);
+  await Promise.all(workers);
+  return results;
+}
+async function runChunk(task, chunkIndex, totalChunks, rowsInChunk, timing, onChunkComplete) {
+  const start = timing || onChunkComplete ? Date.now() : 0;
+  const result = await task();
+  const elapsedMs = start ? Date.now() - start : 0;
+  if (onChunkComplete) {
+    await onChunkComplete({ chunkIndex, totalChunks, rowsInChunk, elapsedMs });
+  }
+  return result;
+}
+async function maybeTransaction(session, transactional, fn8) {
+  if (!transactional) return fn8();
+  const ormSession = session;
+  return ormSession.transaction(fn8);
+}
+function aggregateOutcomes(outcomes) {
+  const result = {
+    processedRows: 0,
+    chunksExecuted: outcomes.length,
+    returning: []
+  };
+  for (const o of outcomes) {
+    result.processedRows += o.processedRows;
+    result.returning.push(...o.returning);
+  }
+  return result;
+}
+function aggregateOutcomesWithTimings(outcomes) {
+  const result = aggregateOutcomes(outcomes);
+  result.chunkTimings = outcomes.map((o) => o.elapsedMs);
+  return result;
+}
+
+// src/bulk/bulk-executor.base.ts
+var DEFAULT_CHUNK_SIZE = 500;
+var BulkBaseExecutor = class {
+  session;
+  table;
+  ctx;
+  options;
+  chunks;
+  totalChunks;
+  constructor(session, table, rows, options = {}) {
+    this.session = session;
+    this.table = table;
+    this.ctx = createBulkExecutionContext(session);
+    this.options = {
+      chunkSize: DEFAULT_CHUNK_SIZE,
+      concurrency: "sequential",
+      transactional: true,
+      timing: false,
+      ...options
+    };
+    this.chunks = splitIntoChunks(rows, this.options.chunkSize);
+    this.totalChunks = this.chunks.length;
+  }
+  async execute() {
+    const buildTask = (chunk, chunkIndex) => async () => {
+      return runChunk(
+        () => this.executeChunk(chunk, chunkIndex),
+        chunkIndex,
+        this.totalChunks,
+        chunk.length,
+        this.options.timing,
+        this.options.onChunkComplete
+      );
+    };
+    const tasks = this.chunks.map((chunk, i) => buildTask(chunk, i));
+    const outcomes = await maybeTransaction(
+      this.session,
+      this.options.transactional,
+      () => runWithConcurrency(tasks, this.options.concurrency)
+    );
+    return this.options.timing ? aggregateOutcomesWithTimings(outcomes) : aggregateOutcomes(outcomes);
+  }
+};
+
+// src/bulk/bulk-insert-executor.ts
+var BulkInsertExecutor = class extends BulkBaseExecutor {
+  constructor(session, table, rows, options = {}) {
+    super(session, table, rows, options);
+  }
+  async executeChunk(chunk, chunkIndex) {
+    const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
+    let builder = new InsertQueryBuilder(this.table).values(chunk);
+    if (this.options.onConflict) {
+      const conflictColumns = this.options.onConflict.target?.columns ?? [];
+      builder = builder.onConflict(conflictColumns);
+      if (this.options.onConflict.action.type === "DoNothing") {
+        builder = builder.doNothing();
+      } else if (this.options.onConflict.action.type === "DoUpdate" && this.options.onConflict.action.set) {
+        const setMap = {};
+        for (const assignment of this.options.onConflict.action.set) {
+          const colName = typeof assignment.column === "object" ? assignment.column.name : assignment.column;
+          setMap[colName] = assignment.value;
+        }
+        builder = builder.doUpdate(setMap);
+      }
+    }
+    const finalBuilder = builder;
+    if (returningColumns?.length) {
+      finalBuilder.returning(...returningColumns);
+    }
+    const compiled = finalBuilder.compile(this.ctx.dialect);
+    const resultSets = await executeCompiled(this.ctx, compiled);
+    return {
+      processedRows: chunk.length,
+      returning: returningColumns ? flattenQueryResults(resultSets) : [],
+      elapsedMs: 0
+    };
+  }
+};
+async function bulkInsert(session, table, rows, options = {}) {
+  if (!rows.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+  const executor = new BulkInsertExecutor(session, table, rows, options);
+  return executor.execute();
+}
+
+// src/bulk/bulk-update-executor.ts
+function resolveByColumns(table, by) {
+  if (!by) return [findPrimaryKey(table)];
+  return Array.isArray(by) ? by : [by];
+}
+var BulkUpdateExecutor = class extends BulkBaseExecutor {
+  byColumns;
+  constructor(session, table, rows, options = {}) {
+    super(session, table, rows, options);
+    this.byColumns = resolveByColumns(table, options.by);
+  }
+  async executeChunk(chunk, chunkIndex) {
+    const allReturning = [];
+    const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
+    const extraWhere = this.options.where;
+    for (const row of chunk) {
+      const predicates = this.byColumns.map((colName) => {
+        const col2 = this.table.columns[colName];
+        if (!col2) {
+          throw new Error(
+            `bulkUpdate: column "${colName}" not found in table "${this.table.name}"`
+          );
+        }
+        const val = row[colName];
+        if (val === void 0) {
+          throw new Error(
+            `bulkUpdate: row is missing the identity column "${colName}" required by the "by" option`
+          );
+        }
+        return eq(col2, val);
+      });
+      const whereExpr = predicates.length === 1 ? predicates[0] : predicates.reduce((acc, p) => and(acc, p), predicates[0]);
+      const finalWhere = extraWhere ? and(whereExpr, extraWhere) : whereExpr;
+      const bySet = new Set(this.byColumns);
+      const setPayload = {};
+      for (const [key, val] of Object.entries(row)) {
+        if (!bySet.has(key) && key in this.table.columns) {
+          setPayload[key] = val;
+        }
+      }
+      if (!Object.keys(setPayload).length) continue;
+      let builder = new UpdateQueryBuilder(this.table).set(setPayload).where(finalWhere);
+      if (returningColumns?.length) {
+        builder = builder.returning(...returningColumns);
+      }
+      const compiled = builder.compile(this.ctx.dialect);
+      const resultSets = await executeCompiled(this.ctx, compiled);
+      if (returningColumns) {
+        allReturning.push(...flattenQueryResults(resultSets));
+      }
+    }
+    return {
+      processedRows: chunk.length,
+      returning: allReturning,
+      elapsedMs: 0
+    };
+  }
+};
+async function bulkUpdate(session, table, rows, options = {}) {
+  if (!rows.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+  const executor = new BulkUpdateExecutor(session, table, rows, options);
+  return executor.execute();
+}
+var DEFAULT_BULK_UPDATE_WHERE_CHUNK_SIZE = 500;
+async function bulkUpdateWhere(session, table, ids, set, options = {}) {
+  if (!ids.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+  const {
+    chunkSize = DEFAULT_BULK_UPDATE_WHERE_CHUNK_SIZE,
+    concurrency = "sequential",
+    transactional = true,
+    timing = false,
+    onChunkComplete,
+    by,
+    where: extraWhere,
+    returning
+  } = options;
+  const ctx = createBulkExecutionContext(session);
+  const byColumnName = by ?? findPrimaryKey(table);
+  const byColumn = table.columns[byColumnName];
+  if (!byColumn) {
+    throw new Error(
+      `bulkUpdateWhere: column "${byColumnName}" not found in table "${table.name}"`
+    );
+  }
+  const returningColumns = resolveReturningColumns(ctx, table, returning);
+  const chunks = splitIntoChunks(ids, chunkSize);
+  const totalChunks = chunks.length;
+  const buildTask = (chunk, chunkIndex) => async () => {
+    return runChunk(
+      async () => {
+        const inExpr = inList(byColumn, chunk);
+        const finalWhere = extraWhere ? and(inExpr, extraWhere) : inExpr;
+        let builder = new UpdateQueryBuilder(table).set(set).where(finalWhere);
+        if (returningColumns?.length) {
+          builder = builder.returning(...returningColumns);
+        }
+        const compiled = builder.compile(ctx.dialect);
+        const resultSets = await executeCompiled(ctx, compiled);
+        return {
+          processedRows: chunk.length,
+          returning: returningColumns ? flattenQueryResults(resultSets) : [],
+          elapsedMs: 0
+        };
+      },
+      chunkIndex,
+      totalChunks,
+      chunk.length,
+      timing,
+      onChunkComplete
+    );
+  };
+  const tasks = chunks.map((chunk, i) => buildTask(chunk, i));
+  const outcomes = await maybeTransaction(
+    session,
+    transactional,
+    () => runWithConcurrency(tasks, concurrency)
+  );
+  return timing ? aggregateOutcomesWithTimings(outcomes) : aggregateOutcomes(outcomes);
+}
+
+// src/bulk/bulk-delete-executor.ts
+var BulkDeleteExecutor = class extends BulkBaseExecutor {
+  byColumnName;
+  constructor(session, table, ids, options = {}) {
+    super(session, table, ids, options);
+    this.byColumnName = options.by ?? findPrimaryKey(table);
+  }
+  async executeChunk(chunk, chunkIndex) {
+    const byColumn = this.table.columns[this.byColumnName];
+    if (!byColumn) {
+      throw new Error(
+        `bulkDelete: column "${this.byColumnName}" not found in table "${this.table.name}"`
+      );
+    }
+    const extraWhere = this.options.where;
+    const inExpr = inList(byColumn, chunk);
+    const finalWhere = extraWhere ? and(inExpr, extraWhere) : inExpr;
+    const builder = new DeleteQueryBuilder(this.table).where(finalWhere);
+    const compiled = builder.compile(this.ctx.dialect);
+    await executeCompiled(this.ctx, compiled);
+    return {
+      processedRows: chunk.length,
+      returning: [],
+      elapsedMs: 0
+    };
+  }
+};
+async function bulkDelete(session, table, ids, options = {}) {
+  if (!ids.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+  const executor = new BulkDeleteExecutor(session, table, ids, options);
+  return executor.execute();
+}
+async function bulkDeleteWhere(session, table, where, options = {}) {
+  const { transactional = false } = options;
+  const ctx = createBulkExecutionContext(session);
+  const builder = new DeleteQueryBuilder(table).where(where);
+  const compiled = builder.compile(ctx.dialect);
+  const execute = async () => {
+    await executeCompiled(ctx, compiled);
+    return { processedRows: 0, chunksExecuted: 1, returning: [] };
+  };
+  return maybeTransaction(session, transactional, execute);
+}
+
+// src/bulk/bulk-upsert-executor.ts
+var DEFAULT_CHUNK_SIZE2 = 500;
+var BulkUpsertExecutor = class extends BulkBaseExecutor {
+  conflictTargetNodes;
+  updateColumns;
+  constructor(session, table, rows, options = {}) {
+    super(session, table, rows, { ...options, chunkSize: options.chunkSize ?? DEFAULT_CHUNK_SIZE2 });
+    const pkName = findPrimaryKey(table);
+    const conflictTargetNames = options.conflictColumns ?? [pkName];
+    this.conflictTargetNodes = conflictTargetNames.map((name) => ({
+      type: "Column",
+      table: table.name,
+      name
+    }));
+    const conflictSet = new Set(conflictTargetNames);
+    this.updateColumns = options.updateColumns ?? Object.keys(rows[0] ?? {}).filter((col2) => !conflictSet.has(col2) && col2 in table.columns);
+  }
+  async executeChunk(chunk, chunkIndex) {
+    const returningColumns = resolveReturningColumns(this.ctx, this.table, this.options.returning);
+    const set = {};
+    for (const col2 of this.updateColumns) {
+      set[col2] = { type: "ExcludedColumn", name: col2 };
+    }
+    let builder;
+    if (this.updateColumns.length === 0) {
+      builder = new InsertQueryBuilder(this.table).values(chunk).onConflict(this.conflictTargetNodes).doNothing();
+    } else {
+      builder = new InsertQueryBuilder(this.table).values(chunk).onConflict(this.conflictTargetNodes).doUpdate(set);
+    }
+    const finalBuilder = builder;
+    if (returningColumns?.length) {
+      finalBuilder.returning(...returningColumns);
+    }
+    const compiled = finalBuilder.compile(this.ctx.dialect);
+    const resultSets = await executeCompiled(this.ctx, compiled);
+    return {
+      processedRows: chunk.length,
+      returning: returningColumns ? flattenQueryResults(resultSets) : [],
+      elapsedMs: 0
+    };
+  }
+};
+async function bulkUpsert(session, table, rows, options = {}) {
+  if (!rows.length) {
+    return { processedRows: 0, chunksExecuted: 0, returning: [] };
+  }
+  const executor = new BulkUpsertExecutor(session, table, rows, options);
+  return executor.execute();
+}
 export {
   Alphanumeric,
   AsyncLocalStorage,
@@ -19691,6 +21543,10 @@ export {
   BigIntTypeStrategy,
   BinaryTypeStrategy,
   BooleanTypeStrategy,
+  BulkDeleteExecutor,
+  BulkInsertExecutor,
+  BulkUpdateExecutor,
+  BulkUpsertExecutor,
   CEP,
   CNPJ,
   CPF,
@@ -19706,6 +21562,9 @@ export {
   DefaultEntityMaterializer,
   DefaultHasManyCollection,
   DefaultManyToManyCollection,
+  DefaultMorphManyCollection,
+  DefaultMorphOneReference,
+  DefaultMorphToReference,
   DefaultTypeStrategy,
   DeleteQueryBuilder,
   DomainEventBus,
@@ -19721,6 +21580,9 @@ export {
   Length,
   Lower,
   MemoryCacheAdapter,
+  MorphMany,
+  MorphOne,
+  MorphTo,
   MySqlDialect,
   NestedSetStrategy,
   Orm,
@@ -19779,6 +21641,12 @@ export {
   bootstrapEntities,
   buildFilterExpression,
   buildScopeConditions,
+  bulkDelete,
+  bulkDeleteWhere,
+  bulkInsert,
+  bulkUpdate,
+  bulkUpdateWhere,
+  bulkUpsert,
   calculateRowDepths,
   calculateTotalPages,
   callProcedure,
@@ -19811,6 +21679,7 @@ export {
   count,
   countAll,
   createApiComponentsSection,
+  createBetterSqlite3Executor,
   createDeterministicNamingState,
   createDtoToOpenApiSchema,
   createEntityFromRow,
@@ -19912,12 +21781,16 @@ export {
   isCastExpressionNode,
   isCollateExpressionNode,
   isComponentReference,
+  isDistinctFrom,
   isExpressionSelectionNode,
   isFunctionNode,
+  isMorphRelation,
+  isNotDistinctFrom,
   isNotNull,
   isNull,
   isNullableColumn,
   isOperandNode,
+  isSingleTargetRelation,
   isTableDef2 as isTableDef,
   isTreeConfig,
   isValidDuration,
@@ -19941,6 +21814,9 @@ export {
   loadBelongsToRelation,
   loadHasManyRelation,
   loadHasOneRelation,
+  loadMorphManyRelation,
+  loadMorphOneRelation,
+  loadMorphToRelation,
   localTime,
   localTimestamp,
   locate,
@@ -19962,11 +21838,15 @@ export {
   minute,
   mod,
   month,
+  morphMany,
+  morphOne,
+  morphTo,
   mul,
   neq,
   nestedDtoToOpenApiSchema,
   nestedWhereInputToOpenApiSchema,
   normalizeColumnType,
+  not,
   notBetween,
   notExists,
   notInList,