Method mergeData

packages/core/src/entity/EntityFactory.ts:220–330

Merges new data into an existing entity, preserving user-modified properties.

(
    meta: EntityMetadata<T>,
    entity: T,
    data: EntityData<T>,
    options: FactoryOptions = {},
  )

  /** Merges new data into an existing entity, preserving user-modified properties. */
  mergeData<T extends object>(
    meta: EntityMetadata<T>,
    entity: T,
    data: EntityData<T>,
    options: FactoryOptions = {},
  ): void {
    // merge unchanged properties automatically
    data = QueryHelper.processParams(data);
    const existsData = this.#comparator.prepareEntity(entity);
    const originalEntityData = helper(entity).__originalEntityData ?? ({} as EntityData<T>);
    const diff = this.#comparator.diffEntities(meta.class, originalEntityData, existsData);

    const diff2 = this.#comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });

    // do not override values changed by user; for uninitialized entities,
    // the diff may include stale snapshot entries (value is undefined) — skip those
    if (helper(entity).__initialized) {
      Utils.keys(diff).forEach(key => delete diff2[key]);
    } else {
      Utils.keys(diff).forEach(key => {
        if (diff[key] !== undefined) {
          delete diff2[key];
        }
      });
    }

    Utils.keys(diff2)
      .filter(key => {
        // ignore null values if there is already present non-null value
        if (existsData[key] != null) {
          return diff2[key] == null;
        }

        return diff2[key] === undefined;
      })
      .forEach(key => delete diff2[key]);

    // but always add collection properties, formulas, generated columns, version properties, and the
    // user-declared STI discriminator if they are part of the `data`, as these are excluded from
    // `comparableProps` and won't appear in the diff
    Utils.keys(data)
      .filter(
        key =>
          meta.properties[key]?.formula ||
          meta.properties[key]?.version ||
          (meta.properties[key]?.generated && !meta.properties[key]?.primary) ||
          [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind) ||
          (key === meta.root.discriminatorColumn && meta.properties[key]?.userDefined !== false),
      )
      .forEach(key => (diff2[key] = data[key]));

    // rehydrated with the new values, skip those changed by user
    // use full hydration if the entity is already initialized, even if the caller used `initialized: false`
    // (e.g. from createReference), otherwise scalar properties in diff2 won't be applied
    const initialized = options.initialized || helper(entity).__initialized;
    this.hydrate(entity, meta, diff2, initialized ? { ...options, initialized } : options);

    // we need to update the entity data only with keys that were not present before