What

processNestedRelations hydrates relations onto parent records, and for every parent record it re-scans the entire relationResults array:

parentRecords.forEach((item) => {
  if (relationType === RelationType.ONE_TO_MANY) {
    item[sourceFieldName] = relationResults.filter((rel) => rel[joinField] === item.id);
  } else {
    const matchedRelation = relationResults.find((rel) => rel.id === item[joinColumnName]);
    ...
  }
});

That is O(n*m) — parent records × relation rows — on every query that selects a relation. A page of 60 records with 500 relation rows is ~30k comparisons, and it grows with both page size and relation cardinality.

How

Index relationResults once before the loop, then look up in O(1):

• ONE_TO_MANY — group by joinField into Map<key, rel[]>, then map.get(item.id) ?? [] (the ?? [] preserves the empty-array result of .filter).
• otherwise — index by id, first occurrence wins so the behaviour matches Array.prototype.find (a plain new Map(arr.map(...)) would keep the last one).

Parent ids are unique, so each ONE_TO_MANY bucket belongs to exactly one parent — no array is shared between records.

No behaviour change; only the lookup strategy.

_{Found with cleanscore (flags linear scans of an outer array inside a loop) and verified by hand. Description drafted with LLM assistance.}