Skip to content

Commit e92de4d

Browse files
egmackeegmacke
authored
fix: issue #98 by improving performance of recurseRelators (#99)
1 parent 7b9b6cb commit e92de4d

File tree

3 files changed

+179
-27
lines changed

3 files changed

+179
-27
lines changed

‎src/classes/relator.ts

+1-1
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ export default class Relator<PrimaryType, RelatedType extends Dictionary<any> =
7979
this.getRelatedData = fetch;
8080
}
8181

82-
private get serializer(): Serializer<RelatedType> {
82+
public get serializer(): Serializer<RelatedType> {
8383
// Instantiate _serializer if not already instantiated
8484
if (!this._serializer) {
8585
this._serializer =

‎src/utils/serializer.utils.ts

+83-26
Original file line numberDiff line numberDiff line change
@@ -2,20 +2,14 @@ import Relator from '../classes/relator';
22
import { SerializerOptions } from '../interfaces/serializer.interface';
33
import { Dictionary } from '../types/global.types';
44

5-
export async function recurseRelators(
5+
async function recurseRelatorsDepth(
66
data: any[],
77
relators: Record<string, Relator<any>>,
8-
include: number | string[] | undefined,
8+
depth: number,
99
keys: string[],
1010
relatorDataCache?: Map<Relator<any>, Dictionary<any>[]>
1111
) {
1212
const included: any[] = [];
13-
let depth =
14-
typeof include === 'number'
15-
? include
16-
: Array.isArray(include)
17-
? Math.max(...include.map((i) => i.split('.').length))
18-
: 0;
1913

2014
let curRelatorDataCache = relatorDataCache || new Map<Relator<any>, Dictionary<any>[]>();
2115

@@ -34,40 +28,103 @@ export async function recurseRelators(
3428
}
3529
}
3630

37-
let currentDepth = 0;
3831
while (depth-- > 0 && curRelatorDataCache.size > 0) {
3932
const newRelatorDataCache = new Map<Relator<any>, Dictionary<any>[]>();
40-
const includeFields: { field: string | undefined; hasMore: boolean }[] | undefined =
41-
Array.isArray(include)
42-
? include
43-
.map((i) => i.split('.'))
44-
.filter((i) => i[currentDepth])
45-
.map((i) => ({ field: i[currentDepth], hasMore: i.length > currentDepth + 1 }))
46-
: undefined;
4733

4834
for (const [relator, cache] of curRelatorDataCache) {
4935
for (let i = 0; i < cache.length; i++) {
50-
const shouldBuildRelatedCache: boolean =
51-
(!includeFields ||
52-
includeFields
53-
?.filter((i) => i.field === relator.relatedName)
54-
?.some((i) => i.hasMore)) ??
55-
false;
56-
5736
const resource = await relator.getRelatedResource(
5837
cache[i],
5938
undefined,
6039
undefined,
61-
// Only build the cache for the next iteration if needed.
62-
shouldBuildRelatedCache ? newRelatorDataCache : undefined
40+
newRelatorDataCache
6341
);
6442

43+
const key = resource.getKey();
44+
if (!keys.includes(key)) {
45+
keys.push(key);
46+
included.push(resource);
47+
}
48+
}
49+
}
50+
51+
curRelatorDataCache = newRelatorDataCache;
52+
}
53+
54+
return included;
55+
}
56+
57+
export async function recurseRelators(
58+
data: any[],
59+
relators: Record<string, Relator<any>>,
60+
include: number | string[] | undefined,
61+
keys: string[],
62+
relatorDataCache?: Map<Relator<any>, Dictionary<any>[]>
63+
) {
64+
if (include === undefined || typeof include === 'number') {
65+
return recurseRelatorsDepth(data, relators, include ?? 0, keys, relatorDataCache);
66+
}
67+
68+
const included: any[] = [];
69+
70+
let curRelatorDataCache = relatorDataCache || new Map<Relator<any>, Dictionary<any>[]>();
71+
72+
// Required to support backwards compatability where the first dataCache may
73+
// not be passed in. All subsequent iterations will contain a dataCache
74+
if (!relatorDataCache && include.length > 0) {
75+
for (const name in relators) {
76+
const cache = curRelatorDataCache.get(relators[name]) || [];
77+
curRelatorDataCache.set(relators[name], cache);
78+
for (const datum of data) {
79+
const relatedData = await relators[name].getRelatedData(datum);
80+
if (relatedData !== null) {
81+
cache.push(...(Array.isArray(relatedData) ? relatedData : [relatedData]));
82+
}
83+
}
84+
}
85+
}
86+
87+
const maxDepth = Math.max(...include.map((i) => i.split('.').length));
88+
89+
let currentDepth = 0;
90+
while (currentDepth < maxDepth) {
91+
const newRelatorDataCache = new Map<Relator<any>, Dictionary<any>[]>();
92+
93+
const includeFields: { field: string | undefined; hasMore: boolean }[] | undefined = include
94+
.map((i) => i.split('.'))
95+
.filter((i) => i[currentDepth])
96+
.map((i) => ({ field: i[currentDepth], hasMore: i.length > currentDepth + 1 }))
97+
.reduce((acc, i) => {
98+
const match = acc.find((j) => j.field === i.field);
99+
if (match) {
100+
match.hasMore = match.hasMore || i.hasMore;
101+
} else {
102+
acc.push(i);
103+
}
104+
return acc;
105+
}, [] as { field: string; hasMore: boolean }[]);
106+
107+
for (const [relator, cache] of curRelatorDataCache) {
108+
const shouldBuildRelatedCache: boolean =
109+
(!includeFields ||
110+
includeFields?.filter((i) => i.field === relator.relatedName)?.some((i) => i.hasMore)) ??
111+
false;
112+
113+
for (let i = 0; i < cache.length; i++) {
65114
// Include if,
66115
// - includeFields !== undefined
67116
// - includeFields has entry where field = relatedName
68117
if (!includeFields || includeFields.map((i) => i.field).includes(relator.relatedName)) {
69-
const key = resource.getKey();
118+
const key = `${relator.serializer.collectionName}:${cache[i].id as string}`;
70119
if (!keys.includes(key)) {
120+
// const key = resource.getKey();
121+
const resource = await relator.getRelatedResource(
122+
cache[i],
123+
undefined,
124+
undefined,
125+
// Only build the cache for the next iteration if needed.
126+
shouldBuildRelatedCache ? newRelatorDataCache : undefined
127+
);
71128
keys.push(key);
72129
included.push(resource);
73130
}

‎test/issue-98.test.ts

+95
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,95 @@
1+
import { Relator, Serializer } from '../src';
2+
3+
describe('Issue 98 - nested relationship recursion performance issues', () => {
4+
class Parent {
5+
constructor(public id: string, public children: Child[]) {}
6+
}
7+
8+
class Child {
9+
constructor(
10+
public id: string,
11+
public name: string,
12+
public nestedChildren: NestedChild[],
13+
public nestedChildren2: NestedChild[]
14+
) {}
15+
}
16+
17+
class NestedChild {
18+
constructor(public id: string, public label: string) {}
19+
}
20+
21+
class NestedChild2 {
22+
constructor(public id: string, public label: string) {}
23+
}
24+
25+
const randomId = (max: number) => {
26+
return Math.ceil(Math.random() * max)
27+
.toFixed(0)
28+
.toString();
29+
};
30+
31+
const makeParent = (): Parent => {
32+
return {
33+
id: randomId(1_000),
34+
children: Array.from({ length: 1_000 }, (_, i) => makeChild()),
35+
};
36+
};
37+
38+
const makeChild = (): Child => {
39+
return {
40+
id: randomId(10),
41+
name: Math.random().toString(),
42+
nestedChildren: Array.from({ length: 500 }, (_, i) => makeNestedChild()),
43+
nestedChildren2: Array.from({ length: 500 }, (_, i) => makeNestedChild2()),
44+
};
45+
};
46+
47+
const makeNestedChild = (): NestedChild => {
48+
return {
49+
id: randomId(10),
50+
label: Math.random().toString(),
51+
};
52+
};
53+
const makeNestedChild2 = (): NestedChild => {
54+
return {
55+
id: randomId(10),
56+
label: Math.random().toString(),
57+
};
58+
};
59+
60+
it('should serialise a massively nested object', async () => {
61+
const object = makeParent();
62+
63+
const NestedChildSerializer = new Serializer<NestedChild>('NestedChild');
64+
const NestedChild2Serializer = new Serializer<NestedChild2>('NestedChild2');
65+
const ChildSerializer = new Serializer<Child>('Child', {
66+
relators: {
67+
nestedChildren: new Relator<Child, NestedChild>(
68+
async (child) => child.nestedChildren,
69+
NestedChildSerializer,
70+
{ relatedName: 'nestedChildren' }
71+
),
72+
nestedChildren2: new Relator<Child, NestedChild>(
73+
async (child) => child.nestedChildren2,
74+
NestedChild2Serializer,
75+
{ relatedName: 'nestedChildren2' }
76+
),
77+
},
78+
});
79+
const ParentSerializer = new Serializer<Parent>('Parent', {
80+
relators: [
81+
new Relator<Parent, Child>(async (parent) => parent.children, ChildSerializer, {
82+
relatedName: 'children',
83+
}),
84+
],
85+
});
86+
87+
const serializedDepth = await ParentSerializer.serialize(object, { include: 2 });
88+
expect(serializedDepth.included).toHaveLength(30);
89+
90+
const serializedInclude = await ParentSerializer.serialize(object, {
91+
include: ['children.nestedChildren', 'children.nestedChildren2'],
92+
});
93+
expect(serializedInclude.included).toHaveLength(30);
94+
});
95+
});

0 commit comments

Comments
 (0)