Function syncCollections

packages/sql/src/AbstractSqlDriver.ts:1697–1822

(
    collections: Iterable<Collection<T, O>>,
    options?: DriverMethodOptions,
  )

  }

  override async syncCollections<T extends object, O extends object>(
    collections: Iterable<Collection<T, O>>,
    options?: DriverMethodOptions,
  ): Promise<void> {
    const groups = {} as Dictionary<PivotCollectionPersister<any>>;

    for (const coll of collections) {
      const wrapped = helper(coll.owner);
      const meta = wrapped.__meta;
      const pks = wrapped.getPrimaryKeys(true)!;
      const snap = coll.getSnapshot();
      const includes = <T>(arr: T[][], item: T[]) => !!arr.find(i => this.comparePrimaryKeyArrays(i, item));
      // For union-target polymorphic M:N, prepend the per-row discriminator value so the pivot
      // persister can write it alongside the FK id. Memoized per sync-run because a collection can
      // hold hundreds of items of the same few types, and findDiscriminatorValue walks the prototype
      // chain + re-scans Object.entries each call.
      const isUnionTargetMN = QueryHelper.isUnionTargetPolymorphic(coll.property);
      const classToDisc = new Map<Function, Primary<any>>();
      const toDiff = (item: AnyEntity) => {
        const keys = helper(item).getPrimaryKeys(true)!;
        if (!isUnionTargetMN) {
          return keys;
        }
        let disc = classToDisc.get(item.constructor);
        if (!classToDisc.has(item.constructor)) {
          disc = QueryHelper.findDiscriminatorValue(coll.property.discriminatorMap!, item.constructor) as Primary<any>;

          if (disc === undefined) {
            throw new Error(
              `Cannot resolve discriminator value for ${item.constructor.name} in ${coll.property.name}; the class is not part of the union target list.`,
            );
          }

          classToDisc.set(item.constructor, disc);
        }
        return [disc as Primary<any>, ...keys];
      };
      const snapshot = snap ? snap.map(toDiff) : [];
      const current = coll.getItems(false).map(toDiff);
      const deleteDiff = snap ? snapshot.filter(item => !includes(current, item)) : true;
      const insertDiff = current.filter(item => !includes(snapshot, item));
      const target = snapshot.filter(item => includes(current, item)).concat(...insertDiff);
      const equals = Utils.equals(current, target);

      // wrong order if we just delete and insert to the end (only owning sides can have fixed order)
      if (coll.property.owner && coll.property.fixedOrder && !equals && Array.isArray(deleteDiff)) {
        deleteDiff.length = insertDiff.length = 0;

        for (const item of snapshot) {
          deleteDiff.push(item);
        }

        for (const item of current) {
          insertDiff.push(item);
        }
      }

      if (coll.property.kind === ReferenceKind.ONE_TO_MANY) {