@mikro-orm/core 7.0.2-dev.8 → 7.0.2

package/unit-of-work/ChangeSet.js

@@ -1,65 +1,69 @@
 import { helper } from '../entity/wrap.js';
 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;
+  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]];
     }
-    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 (
+      !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];
+      });
     }
-    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;
+    if (object && this.primaryKey != null) {
+      return Utils.primaryKeyToObject(this.meta, this.primaryKey);
     }
+    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

@@ -2,16 +2,18 @@ import type { AnyEntity } from '../typings.js';
 import { ChangeSet } from './ChangeSet.js';
 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>>);
-    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

@@ -6,169 +6,190 @@ import { validateEntity } from '../entity/validators.js';
 import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 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);
-    }
-    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);
-        }
-        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]) {
-            for (const embeddedProp of prop.targetMeta.hydrateProps) {
-                this.processPropertyInitializers(entity[prop.name], 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;
     }
-    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;
+    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);
+      }
     }
-    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 (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
+      const data = this.#comparator.prepareEntity(entity);
+      if (Utils.equals(data, wrapped.__originalEntityData)) {
+        return null;
+      }
     }
-    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();
-            });
+    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;
+    }
+    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

@@ -2,46 +2,69 @@ import type { Dictionary, EntityDictionary, EntityMetadata } from '../typings.js
 import { type ChangeSet } from './ChangeSet.js';
 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);
-    executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
-    executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
-    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;
 }