@mikro-orm/core 7.0.2 → 7.0.3-dev.1

package/unit-of-work/ChangeSet.js

@@ -3,67 +3,67 @@ import { Utils } from '../utils/Utils.js';
 import { inspect } from '../logging/inspect.js';
 /** Represents a pending change (create, update, or delete) for a single entity. */
 export class ChangeSet {
-  entity;
-  type;
-  payload;
-  meta;
-  primaryKey;
-  serializedPrimaryKey;
-  constructor(entity, type, payload, meta) {
-    this.entity = entity;
-    this.type = type;
-    this.payload = payload;
-    this.meta = meta;
-    this.meta = meta;
-    this.rootMeta = meta.root;
-    this.schema = helper(entity).__schema ?? meta.root.schema;
-  }
-  /** Returns the primary key of the entity, optionally as an object for composite keys. */
-  getPrimaryKey(object = false) {
-    if (!this.originalEntity) {
-      this.primaryKey ??= helper(this.entity).getPrimaryKey(true);
-    } else if (this.meta.compositePK) {
-      this.primaryKey = this.meta.primaryKeys.map(pk => this.originalEntity[pk]);
-    } else {
-      this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
+    entity;
+    type;
+    payload;
+    meta;
+    primaryKey;
+    serializedPrimaryKey;
+    constructor(entity, type, payload, meta) {
+        this.entity = entity;
+        this.type = type;
+        this.payload = payload;
+        this.meta = meta;
+        this.meta = meta;
+        this.rootMeta = meta.root;
+        this.schema = helper(entity).__schema ?? meta.root.schema;
     }
-    if (
-      !this.meta.compositePK &&
-      this.meta.getPrimaryProp().targetMeta?.compositePK &&
-      typeof this.primaryKey === 'object' &&
-      this.primaryKey !== null
-    ) {
-      this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
-        return this.primaryKey[childPK];
-      });
+    /** Returns the primary key of the entity, optionally as an object for composite keys. */
+    getPrimaryKey(object = false) {
+        if (!this.originalEntity) {
+            this.primaryKey ??= helper(this.entity).getPrimaryKey(true);
+        }
+        else if (this.meta.compositePK) {
+            this.primaryKey = this.meta.primaryKeys.map(pk => this.originalEntity[pk]);
+        }
+        else {
+            this.primaryKey = this.originalEntity[this.meta.primaryKeys[0]];
+        }
+        if (!this.meta.compositePK &&
+            this.meta.getPrimaryProp().targetMeta?.compositePK &&
+            typeof this.primaryKey === 'object' &&
+            this.primaryKey !== null) {
+            this.primaryKey = this.meta.getPrimaryProp().targetMeta.primaryKeys.map(childPK => {
+                return this.primaryKey[childPK];
+            });
+        }
+        if (object && this.primaryKey != null) {
+            return Utils.primaryKeyToObject(this.meta, this.primaryKey);
+        }
+        return this.primaryKey ?? null;
     }
-    if (object && this.primaryKey != null) {
-      return Utils.primaryKeyToObject(this.meta, this.primaryKey);
+    /** Returns the serialized (string) form of the primary key. */
+    getSerializedPrimaryKey() {
+        this.serializedPrimaryKey ??= helper(this.entity).getSerializedPrimaryKey();
+        return this.serializedPrimaryKey;
+    }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
+        const object = { ...this };
+        const hidden = ['meta', 'serializedPrimaryKey'];
+        hidden.forEach(k => delete object[k]);
+        const ret = inspect(object, { depth });
+        const name = `${this.constructor.name}<${this.meta.className}>`;
+        /* v8 ignore next */
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
-    return this.primaryKey ?? null;
-  }
-  /** Returns the serialized (string) form of the primary key. */
-  getSerializedPrimaryKey() {
-    this.serializedPrimaryKey ??= helper(this.entity).getSerializedPrimaryKey();
-    return this.serializedPrimaryKey;
-  }
-  /** @ignore */
-  [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
-    const object = { ...this };
-    const hidden = ['meta', 'serializedPrimaryKey'];
-    hidden.forEach(k => delete object[k]);
-    const ret = inspect(object, { depth });
-    const name = `${this.constructor.name}<${this.meta.className}>`;
-    /* v8 ignore next */
-    return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
-  }
 }
 /** Enumeration of change set operation types. */
 export var ChangeSetType;
 (function (ChangeSetType) {
-  ChangeSetType['CREATE'] = 'create';
-  ChangeSetType['UPDATE'] = 'update';
-  ChangeSetType['DELETE'] = 'delete';
-  ChangeSetType['UPDATE_EARLY'] = 'update_early';
-  ChangeSetType['DELETE_EARLY'] = 'delete_early';
+    ChangeSetType["CREATE"] = "create";
+    ChangeSetType["UPDATE"] = "update";
+    ChangeSetType["DELETE"] = "delete";
+    ChangeSetType["UPDATE_EARLY"] = "update_early";
+    ChangeSetType["DELETE_EARLY"] = "delete_early";
 })(ChangeSetType || (ChangeSetType = {}));

package/unit-of-work/ChangeSetComputer.d.ts

@@ -4,16 +4,16 @@ import { type Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 /** @internal Computes change sets by comparing entity state against original snapshots. */
 export declare class ChangeSetComputer {
-  #private;
-  constructor(em: EntityManager, collectionUpdates: Set<Collection<AnyEntity>>);
-  /** Computes a change set for the given entity by diffing against its original state. */
-  computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
-  /**
-   * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
-   */
-  private processPropertyInitializers;
-  private computePayload;
-  private processProperty;
-  private processToOne;
-  private processToMany;
+    #private;
+    constructor(em: EntityManager, collectionUpdates: Set<Collection<AnyEntity>>);
+    /** Computes a change set for the given entity by diffing against its original state. */
+    computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
+    /**
+     * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
+     */
+    private processPropertyInitializers;
+    private computePayload;
+    private processProperty;
+    private processToOne;
+    private processToMany;
 }

package/unit-of-work/ChangeSetComputer.js

@@ -9,187 +9,179 @@ import { ReferenceKind } from '../enums.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
 /** @internal Computes change sets by comparing entity state against original snapshots. */
 export class ChangeSetComputer {
-  #comparator;
-  #metadata;
-  #platform;
-  #config;
-  #em;
-  #collectionUpdates;
-  constructor(em, collectionUpdates) {
-    this.#em = em;
-    this.#collectionUpdates = collectionUpdates;
-    this.#config = this.#em.config;
-    this.#metadata = this.#em.getMetadata();
-    this.#platform = this.#em.getPlatform();
-    this.#comparator = this.#config.getComparator(this.#metadata);
-  }
-  /** Computes a change set for the given entity by diffing against its original state. */
-  computeChangeSet(entity) {
-    const meta = this.#metadata.get(entity.constructor);
-    if (meta.readonly) {
-      return null;
-    }
-    const wrapped = helper(entity);
-    const type = wrapped.__originalEntityData ? ChangeSetType.UPDATE : ChangeSetType.CREATE;
-    const map = new Map();
-    // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
-    // to the `map` as we want to apply those only if something else changed.
-    if (type === ChangeSetType.CREATE) {
-      // run update hooks only after we know there are other changes
-      for (const prop of meta.hydrateProps) {
-        this.processPropertyInitializers(entity, prop, type, map);
-      }
-    }
-    if (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
-      const data = this.#comparator.prepareEntity(entity);
-      if (Utils.equals(data, wrapped.__originalEntityData)) {
-        return null;
-      }
-    }
-    const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
-    changeSet.originalEntity = wrapped.__originalEntityData;
-    for (const prop of meta.relations.filter(prop => prop.persist !== false || prop.userDefined === false)) {
-      this.processProperty(changeSet, prop);
-    }
-    if (changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload)) {
-      return null;
-    }
-    validateEntity(changeSet.entity, meta);
-    // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
-    // to the `map` as we want to apply those only if something else changed.
-    if (type === ChangeSetType.UPDATE) {
-      for (const prop of meta.hydrateProps) {
-        this.processPropertyInitializers(entity, prop, type, map);
-      }
-    }
-    if (map.size > 0) {
-      for (const [entity, pairs] of map) {
-        for (const [prop, value] of pairs) {
-          entity[prop] = value;
-        }
-      }
-      // Recompute the changeset, we need to merge this as here we ignore relations.
-      const diff = this.computePayload(entity, true);
-      Utils.merge(changeSet.payload, diff);
-    }
-    return changeSet;
-  }
-  /**
-   * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
-   */
-  processPropertyInitializers(entity, prop, type, map, nested) {
-    if (
-      prop.onCreate &&
-      type === ChangeSetType.CREATE &&
-      (entity[prop.name] == null || (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))
-    ) {
-      entity[prop.name] = prop.onCreate(entity, this.#em);
-    } else if (
-      prop.default != null &&
-      !isRaw(prop.default) &&
-      ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
-      type === ChangeSetType.CREATE &&
-      entity[prop.name] === undefined
-    ) {
-      entity[prop.name] = prop.default;
-    }
-    if (prop.onUpdate && type === ChangeSetType.UPDATE) {
-      const pairs = map.get(entity) ?? [];
-      pairs.push([prop.name, prop.onUpdate(entity, this.#em)]);
-      map.set(entity, pairs);
-    }
-    if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
-      const items = prop.array ? entity[prop.name] : [entity[prop.name]];
-      for (const item of items) {
-        for (const embeddedProp of prop.targetMeta.hydrateProps) {
-          this.processPropertyInitializers(item, embeddedProp, type, map, nested || prop.object);
+    #comparator;
+    #metadata;
+    #platform;
+    #config;
+    #em;
+    #collectionUpdates;
+    constructor(em, collectionUpdates) {
+        this.#em = em;
+        this.#collectionUpdates = collectionUpdates;
+        this.#config = this.#em.config;
+        this.#metadata = this.#em.getMetadata();
+        this.#platform = this.#em.getPlatform();
+        this.#comparator = this.#config.getComparator(this.#metadata);
+    }
+    /** Computes a change set for the given entity by diffing against its original state. */
+    computeChangeSet(entity) {
+        const meta = this.#metadata.get(entity.constructor);
+        if (meta.readonly) {
+            return null;
+        }
+        const wrapped = helper(entity);
+        const type = wrapped.__originalEntityData ? ChangeSetType.UPDATE : ChangeSetType.CREATE;
+        const map = new Map();
+        // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
+        // to the `map` as we want to apply those only if something else changed.
+        if (type === ChangeSetType.CREATE) {
+            // run update hooks only after we know there are other changes
+            for (const prop of meta.hydrateProps) {
+                this.processPropertyInitializers(entity, prop, type, map);
+            }
+        }
+        if (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
+            const data = this.#comparator.prepareEntity(entity);
+            if (Utils.equals(data, wrapped.__originalEntityData)) {
+                return null;
+            }
+        }
+        const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
+        changeSet.originalEntity = wrapped.__originalEntityData;
+        for (const prop of meta.relations.filter(prop => prop.persist !== false || prop.userDefined === false)) {
+            this.processProperty(changeSet, prop);
+        }
+        if (changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload)) {
+            return null;
+        }
+        validateEntity(changeSet.entity, meta);
+        // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
+        // to the `map` as we want to apply those only if something else changed.
+        if (type === ChangeSetType.UPDATE) {
+            for (const prop of meta.hydrateProps) {
+                this.processPropertyInitializers(entity, prop, type, map);
+            }
+        }
+        if (map.size > 0) {
+            for (const [entity, pairs] of map) {
+                for (const [prop, value] of pairs) {
+                    entity[prop] = value;
+                }
+            }
+            // Recompute the changeset, we need to merge this as here we ignore relations.
+            const diff = this.computePayload(entity, true);
+            Utils.merge(changeSet.payload, diff);
+        }
+        return changeSet;
+    }
+    /**
+     * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
+     */
+    processPropertyInitializers(entity, prop, type, map, nested) {
+        if (prop.onCreate &&
+            type === ChangeSetType.CREATE &&
+            (entity[prop.name] == null ||
+                (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
+            entity[prop.name] = prop.onCreate(entity, this.#em);
+        }
+        else if (prop.default != null &&
+            !isRaw(prop.default) &&
+            ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+            type === ChangeSetType.CREATE &&
+            entity[prop.name] === undefined) {
+            entity[prop.name] = prop.default;
+        }
+        if (prop.onUpdate && type === ChangeSetType.UPDATE) {
+            const pairs = map.get(entity) ?? [];
+            pairs.push([prop.name, prop.onUpdate(entity, this.#em)]);
+            map.set(entity, pairs);
+        }
+        if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
+            const items = prop.array ? entity[prop.name] : [entity[prop.name]];
+            for (const item of items) {
+                for (const embeddedProp of prop.targetMeta.hydrateProps) {
+                    this.processPropertyInitializers(item, embeddedProp, type, map, nested || prop.object);
+                }
+            }
         }
-      }
-    }
-  }
-  computePayload(entity, ignoreUndefined = false) {
-    const data = this.#comparator.prepareEntity(entity);
-    const wrapped = helper(entity);
-    const entityName = wrapped.__meta.class;
-    const originalEntityData = wrapped.__originalEntityData;
-    if (!wrapped.__initialized) {
-      for (const prop of wrapped.__meta.primaryKeys) {
-        delete data[prop];
-      }
-      return data;
-    }
-    if (originalEntityData) {
-      const comparator = this.#comparator.getEntityComparator(entityName);
-      const diff = comparator(originalEntityData, data);
-      if (ignoreUndefined) {
-        Utils.keys(diff)
-          .filter(k => diff[k] === undefined)
-          .forEach(k => delete diff[k]);
-      }
-      return diff;
-    }
-    return data;
-  }
-  processProperty(changeSet, prop, target) {
-    if (!target) {
-      const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
-      targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
-      return;
-    }
-    if (Utils.isCollection(target)) {
-      // m:n or 1:m
-      this.processToMany(prop, changeSet);
-    }
-    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-      this.processToOne(prop, changeSet);
-    }
-  }
-  processToOne(prop, changeSet) {
-    const isToOneOwner =
-      prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
-    if (!isToOneOwner || prop.mapToPk) {
-      return;
     }
-    const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
-    targets.forEach(([rawTarget, idx]) => {
-      const target = Reference.unwrapReference(rawTarget);
-      const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
-      if (needsProcessing) {
-        let value = prop.targetKey ? target[prop.targetKey] : target.__helper.__identifier;
-        /* v8 ignore next */
-        if (prop.targetKey && prop.targetMeta) {
-          const targetProp = prop.targetMeta.properties[prop.targetKey];
-          if (targetProp?.customType) {
-            value = targetProp.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' });
-          }
-        }
-        if (prop.polymorphic) {
-          const discriminator = QueryHelper.findDiscriminatorValue(prop.discriminatorMap, target.constructor);
-          Utils.setPayloadProperty(
-            changeSet.payload,
-            changeSet.meta,
-            prop,
-            new PolymorphicRef(discriminator, value),
-            idx,
-          );
-        } else {
-          Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
-        }
-      }
-    });
-  }
-  processToMany(prop, changeSet) {
-    const target = changeSet.entity[prop.name];
-    if (!target.isDirty() && changeSet.type !== ChangeSetType.CREATE) {
-      return;
+    computePayload(entity, ignoreUndefined = false) {
+        const data = this.#comparator.prepareEntity(entity);
+        const wrapped = helper(entity);
+        const entityName = wrapped.__meta.class;
+        const originalEntityData = wrapped.__originalEntityData;
+        if (!wrapped.__initialized) {
+            for (const prop of wrapped.__meta.primaryKeys) {
+                delete data[prop];
+            }
+            return data;
+        }
+        if (originalEntityData) {
+            const comparator = this.#comparator.getEntityComparator(entityName);
+            const diff = comparator(originalEntityData, data);
+            if (ignoreUndefined) {
+                Utils.keys(diff)
+                    .filter(k => diff[k] === undefined)
+                    .forEach(k => delete diff[k]);
+            }
+            return diff;
+        }
+        return data;
     }
-    if (target.isDirty()) {
-      this.#collectionUpdates.add(target);
+    processProperty(changeSet, prop, target) {
+        if (!target) {
+            const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+            targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
+            return;
+        }
+        if (Utils.isCollection(target)) {
+            // m:n or 1:m
+            this.processToMany(prop, changeSet);
+        }
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            this.processToOne(prop, changeSet);
+        }
     }
-    if (prop.owner && !this.#platform.usesPivotTable()) {
-      changeSet.payload[prop.name] = target.getItems(false).map(item => {
-        return item.__helper.__identifier ?? item.__helper.getPrimaryKey();
-      });
+    processToOne(prop, changeSet) {
+        const isToOneOwner = prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
+        if (!isToOneOwner || prop.mapToPk) {
+            return;
+        }
+        const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+        targets.forEach(([rawTarget, idx]) => {
+            const target = Reference.unwrapReference(rawTarget);
+            const needsProcessing = target != null && (prop.targetKey != null || !target.__helper.hasPrimaryKey());
+            if (needsProcessing) {
+                let value = prop.targetKey ? target[prop.targetKey] : target.__helper.__identifier;
+                /* v8 ignore next */
+                if (prop.targetKey && prop.targetMeta) {
+                    const targetProp = prop.targetMeta.properties[prop.targetKey];
+                    if (targetProp?.customType) {
+                        value = targetProp.customType.convertToDatabaseValue(value, this.#platform, { mode: 'serialization' });
+                    }
+                }
+                if (prop.polymorphic) {
+                    const discriminator = QueryHelper.findDiscriminatorValue(prop.discriminatorMap, target.constructor);
+                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, new PolymorphicRef(discriminator, value), idx);
+                }
+                else {
+                    Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, value, idx);
+                }
+            }
+        });
+    }
+    processToMany(prop, changeSet) {
+        const target = changeSet.entity[prop.name];
+        if (!target.isDirty() && changeSet.type !== ChangeSetType.CREATE) {
+            return;
+        }
+        if (target.isDirty()) {
+            this.#collectionUpdates.add(target);
+        }
+        if (prop.owner && !this.#platform.usesPivotTable()) {
+            changeSet.payload[prop.name] = target.getItems(false).map((item) => {
+                return item.__helper.__identifier ?? item.__helper.getPrimaryKey();
+            });
+        }
     }
-  }
 }

package/unit-of-work/ChangeSetPersister.d.ts

@@ -4,67 +4,48 @@ import type { DriverMethodOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityManager } from '../EntityManager.js';
 /** @internal Executes change sets against the database, handling inserts, updates, and deletes. */
 export declare class ChangeSetPersister {
-  #private;
-  constructor(em: EntityManager);
-  /** Executes all pending INSERT change sets, using batch inserts when possible. */
-  executeInserts<T extends object>(
-    changeSets: ChangeSet<T>[],
-    options?: DriverMethodOptions,
-    withSchema?: boolean,
-  ): Promise<void>;
-  /** Executes all pending UPDATE change sets, using batch updates when possible. */
-  executeUpdates<T extends object>(
-    changeSets: ChangeSet<T>[],
-    batched: boolean,
-    options?: DriverMethodOptions,
-    withSchema?: boolean,
-  ): Promise<void>;
-  /** Executes all pending DELETE change sets in batches. */
-  executeDeletes<T extends object>(
-    changeSets: ChangeSet<T>[],
-    options?: DriverMethodOptions,
-    withSchema?: boolean,
-  ): Promise<void>;
-  private runForEachSchema;
-  private validateRequired;
-  private processProperties;
-  private persistNewEntity;
-  private persistNewEntities;
-  private prepareOptions;
-  private persistNewEntitiesBatch;
-  private persistManagedEntity;
-  private persistManagedEntities;
-  private checkConcurrencyKeys;
-  private persistManagedEntitiesBatch;
-  private mapPrimaryKey;
-  /**
-   * Sets populate flag to new entities so they are serialized like if they were loaded from the db
-   */
-  private markAsPopulated;
-  private updateEntity;
-  private checkOptimisticLocks;
-  private checkOptimisticLock;
-  /**
-   * This method also handles reloading of database default values for inserts and raw property updates,
-   * so we use a single query in case of both versioning and default values is used.
-   */
-  private reloadVersionValues;
-  /**
-   * For TPT child tables, resolve EntityIdentifier values in PK fields.
-   * The parent table insert assigns the actual PK value, which the child table references.
-   */
-  private resolveTPTIdentifiers;
-  private processProperty;
-  /**
-   * Maps values returned via `returning` statement (postgres) or the inserted id (other sql drivers).
-   * No need to handle composite keys here as they need to be set upfront.
-   * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
-   */
-  mapReturnedValues<T extends object>(
-    entity: T | null | undefined,
-    payload: EntityDictionary<T>,
-    row: Dictionary | undefined,
-    meta: EntityMetadata<T>,
-    upsert?: boolean,
-  ): void;
+    #private;
+    constructor(em: EntityManager);
+    /** Executes all pending INSERT change sets, using batch inserts when possible. */
+    executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
+    /** Executes all pending UPDATE change sets, using batch updates when possible. */
+    executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
+    /** Executes all pending DELETE change sets in batches. */
+    executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
+    private runForEachSchema;
+    private validateRequired;
+    private processProperties;
+    private persistNewEntity;
+    private persistNewEntities;
+    private prepareOptions;
+    private persistNewEntitiesBatch;
+    private persistManagedEntity;
+    private persistManagedEntities;
+    private checkConcurrencyKeys;
+    private persistManagedEntitiesBatch;
+    private mapPrimaryKey;
+    /**
+     * Sets populate flag to new entities so they are serialized like if they were loaded from the db
+     */
+    private markAsPopulated;
+    private updateEntity;
+    private checkOptimisticLocks;
+    private checkOptimisticLock;
+    /**
+     * This method also handles reloading of database default values for inserts and raw property updates,
+     * so we use a single query in case of both versioning and default values is used.
+     */
+    private reloadVersionValues;
+    /**
+     * For TPT child tables, resolve EntityIdentifier values in PK fields.
+     * The parent table insert assigns the actual PK value, which the child table references.
+     */
+    private resolveTPTIdentifiers;
+    private processProperty;
+    /**
+     * Maps values returned via `returning` statement (postgres) or the inserted id (other sql drivers).
+     * No need to handle composite keys here as they need to be set upfront.
+     * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
+     */
+    mapReturnedValues<T extends object>(entity: T | null | undefined, payload: EntityDictionary<T>, row: Dictionary | undefined, meta: EntityMetadata<T>, upsert?: boolean): void;
 }