fork of hey-api/openapi-ts because I need some additional things
Merge pull request #2481 from hey-api/fix/graph-perf-2
fix(parser): cache parent to children nodes
+173
-143
+5
.changeset/khaki-rabbits-explain.md
+5
.changeset/khaki-rabbits-explain.md
+3
-3
packages/openapi-ts-tests/main/test/openapi-ts.config.ts
+3
-3
packages/openapi-ts-tests/main/test/openapi-ts.config.ts
···
54
54
// },
55
55
},
56
56
logs: {
57
-
// level: 'debug',
57
+
level: 'debug',
58
58
path: './logs',
59
59
},
60
60
// name: 'foo',
···
80
80
// // '/^[A-Z]+ /v1//',
81
81
// ],
82
82
},
83
-
// orphans: false,
83
+
// orphans: true,
84
84
// preserveOrder: true,
85
85
// schemas: {
86
86
// include: ['Foo'],
···
190
190
// mutationOptions: {
191
191
// name: '{{name}}MO',
192
192
// },
193
-
// name: '@tanstack/react-query',
193
+
name: '@tanstack/react-query',
194
194
// queryKeys: {
195
195
// name: '{{name}}QK',
196
196
// },
+46
-42
packages/openapi-ts-tests/main/test/performance.test.ts
+46
-42
packages/openapi-ts-tests/main/test/performance.test.ts
···
1
1
import path from 'node:path';
2
2
3
-
import { createClient } from '@hey-api/openapi-ts';
4
-
import { describe, expect, it } from 'vitest';
3
+
import { createClient, Logger } from '@hey-api/openapi-ts';
4
+
import { beforeEach, describe, expect, it } from 'vitest';
5
5
6
-
import { Performance } from '../../../openapi-ts/src/utils/logger';
7
6
import { getSpecsPath } from '../../utils';
8
7
9
8
const V3_SPEC_PATH = path.resolve(getSpecsPath(), 'v3.json');
···
13
12
path.resolve(__dirname, 'generated', name);
14
13
15
14
describe('performance', () => {
16
-
it('creates client under 1500ms', async () => {
17
-
Performance.clear();
15
+
beforeEach(() => {
16
+
performance.clearMarks();
17
+
performance.clearMeasures();
18
+
});
18
19
19
-
await createClient({
20
-
input: V3_SPEC_PATH,
21
-
logs: {
22
-
level: 'silent',
20
+
it('creates client under 1500ms', async () => {
21
+
const logger = new Logger();
22
+
await createClient(
23
+
{
24
+
input: V3_SPEC_PATH,
25
+
logs: {
26
+
level: 'silent',
27
+
},
28
+
output: toOutputPath('perf'),
29
+
plugins: ['@hey-api/client-fetch'],
23
30
},
24
-
output: toOutputPath('perf'),
25
-
plugins: ['@hey-api/client-fetch'],
26
-
});
27
-
28
-
Performance.measure('createClient');
29
-
const measures = Performance.getEntriesByName('createClient');
31
+
logger,
32
+
);
30
33
31
-
expect(measures[0]!.duration).toBeLessThanOrEqual(1500);
34
+
const duration = logger.report()?.duration ?? 9999;
35
+
expect(duration).toBeLessThanOrEqual(1500);
32
36
});
33
37
34
38
it('parses spec under 1500ms', async () => {
35
-
Performance.clear();
36
-
37
-
await createClient({
38
-
input: V3_SPEC_PATH,
39
-
logs: {
40
-
level: 'silent',
39
+
const logger = new Logger();
40
+
await createClient(
41
+
{
42
+
input: V3_SPEC_PATH,
43
+
logs: {
44
+
level: 'silent',
45
+
},
46
+
output: toOutputPath('perf'),
47
+
plugins: ['@hey-api/client-fetch'],
41
48
},
42
-
output: toOutputPath('perf'),
43
-
plugins: ['@hey-api/client-fetch'],
44
-
});
45
-
46
-
Performance.measure('parser');
47
-
const measures = Performance.getEntriesByName('parser');
49
+
logger,
50
+
);
48
51
49
-
expect(measures[0]!.duration).toBeLessThanOrEqual(1500);
52
+
const duration = logger.report()?.duration ?? 9999;
53
+
expect(duration).toBeLessThanOrEqual(1500);
50
54
});
51
55
52
56
it('parses spec under 1500ms (experimental)', async () => {
53
-
Performance.clear();
54
-
55
-
await createClient({
56
-
input: V3_1_X_SPEC_PATH,
57
-
logs: {
58
-
level: 'silent',
57
+
const logger = new Logger();
58
+
await createClient(
59
+
{
60
+
input: V3_1_X_SPEC_PATH,
61
+
logs: {
62
+
level: 'silent',
63
+
},
64
+
output: toOutputPath('perf'),
65
+
plugins: ['@hey-api/client-fetch'],
59
66
},
60
-
output: toOutputPath('perf'),
61
-
plugins: ['@hey-api/client-fetch'],
62
-
});
67
+
logger,
68
+
);
63
69
64
-
Performance.measure('parser');
65
-
const measures = Performance.getEntriesByName('parser');
66
-
67
-
expect(measures[0]!.duration).toBeLessThanOrEqual(1500);
70
+
const duration = logger.report()?.duration ?? 9999;
71
+
expect(duration).toBeLessThanOrEqual(1500);
68
72
});
69
73
});
+3
-4
packages/openapi-ts/src/index.ts
+3
-4
packages/openapi-ts/src/index.ts
···
29
29
*/
30
30
export const createClient = async (
31
31
userConfig?: Configs,
32
+
logger = new Logger(),
32
33
): Promise<ReadonlyArray<Client | IR.Context>> => {
33
34
const resolvedConfig =
34
35
typeof userConfig === 'function' ? await userConfig() : userConfig;
···
38
39
try {
39
40
checkNodeVersion();
40
41
41
-
const logger = new Logger();
42
42
const eventCreateClient = logger.timeEvent('createClient');
43
43
44
44
const eventConfig = logger.timeEvent('config');
···
72
72
eventCreateClient.timeEnd();
73
73
74
74
const config = configs[0];
75
-
if (config && config.logs.level === 'debug') {
76
-
logger.report();
77
-
}
75
+
logger.report(config && config.logs.level === 'debug');
78
76
79
77
return result;
80
78
} catch (error) {
···
134
132
export type { UserConfig } from './types/config';
135
133
export type { LegacyIR } from './types/types';
136
134
export { utils } from './utils/exports';
135
+
export { Logger } from './utils/logger';
+32
-36
packages/openapi-ts/src/utils/logger.ts
+32
-36
packages/openapi-ts/src/utils/logger.ts
···
3
3
interface LoggerEvent {
4
4
end?: PerformanceMark;
5
5
events: Array<LoggerEvent>;
6
+
id: string; // unique internal key
6
7
name: string;
7
8
start: PerformanceMark;
8
9
}
···
16
17
position: ReadonlyArray<number>;
17
18
}
18
19
20
+
let loggerCounter = 0;
21
+
const nameToId = (name: string) => `${name}-${loggerCounter++}`;
19
22
const idEnd = (id: string) => `${id}-end`;
20
-
21
23
const idLength = (id: string) => `${id}-length`;
22
-
23
24
const idStart = (id: string) => `${id}-start`;
24
25
25
-
export const Performance = {
26
-
clear: (): void => {
27
-
performance.clearMarks();
28
-
performance.clearMeasures();
29
-
},
30
-
end: (id: string): PerformanceMark => performance.mark(idEnd(id)),
31
-
getEntriesByName: (id: string): PerformanceEntryList =>
32
-
performance.getEntriesByName(idLength(id)),
33
-
measure: (id: string): PerformanceMeasure =>
34
-
performance.measure(idLength(id), idStart(id), idEnd(id)),
35
-
start: (id: string): PerformanceMark => performance.mark(idStart(id)),
36
-
};
37
-
38
26
const getSeverity = (
39
27
duration: number,
40
28
percentage: number,
···
79
67
}
80
68
}
81
69
if (event && !event.end) {
82
-
event.end = performance.mark(idEnd(event.name));
70
+
event.end = performance.mark(idEnd(event.id));
83
71
}
84
72
}
85
73
86
-
report() {
74
+
report(print: boolean = true): PerformanceMeasure | undefined {
87
75
const firstEvent = this.events[0];
88
76
if (!firstEvent) return;
89
77
const lastEvent = this.events[this.events.length - 1]!;
78
+
const name = 'root';
79
+
const id = nameToId(name);
90
80
const measure = performance.measure(
91
-
idLength('root'),
92
-
idStart(firstEvent.name),
93
-
idEnd(lastEvent.name),
81
+
idLength(id),
82
+
idStart(firstEvent.id),
83
+
idEnd(lastEvent.id),
94
84
);
95
-
this.reportEvent({
96
-
end: lastEvent.end,
97
-
events: this.events,
98
-
indent: 0,
99
-
measure,
100
-
name: 'root',
101
-
start: firstEvent!.start,
102
-
});
85
+
if (print) {
86
+
this.reportEvent({
87
+
end: lastEvent.end,
88
+
events: this.events,
89
+
id,
90
+
indent: 0,
91
+
measure,
92
+
name,
93
+
start: firstEvent!.start,
94
+
});
95
+
}
96
+
return measure;
103
97
}
104
98
105
99
private reportEvent({
···
114
108
115
109
parent.events.forEach((event, index) => {
116
110
const measure = performance.measure(
117
-
idLength(event.name),
118
-
idStart(event.name),
119
-
idEnd(event.name),
111
+
idLength(event.id),
112
+
idStart(event.id),
113
+
idEnd(event.id),
120
114
);
121
115
const duration = Math.ceil(measure.duration * 100) / 100;
122
116
const percentage =
···
131
125
132
126
const branch = index === lastIndex ? '└─ ' : '├─ ';
133
127
const prefix = !indent ? '' : '│ '.repeat(indent - 1) + branch;
134
-
const maxLength = 30 - prefix.length;
128
+
const maxLength = 38 - prefix.length;
135
129
136
130
const percentageBranch = !indent ? '' : '↳ ';
137
131
const percentagePrefix = indent
···
151
145
});
152
146
}
153
147
154
-
private start(name: string): PerformanceMark {
155
-
return performance.mark(idStart(name));
148
+
private start(id: string): PerformanceMark {
149
+
return performance.mark(idStart(id));
156
150
}
157
151
158
152
private storeEvent({
159
153
result,
160
154
...event
161
-
}: Pick<LoggerEvent, 'events' | 'name' | 'start'> & {
155
+
}: Pick<LoggerEvent, 'events' | 'id' | 'name' | 'start'> & {
162
156
result: StoredEventResult;
163
157
}): void {
164
158
const lastEventIndex = event.events.length - 1;
···
173
167
}
174
168
175
169
timeEvent(name: string) {
176
-
const start = this.start(name);
170
+
const id = nameToId(name);
171
+
const start = this.start(id);
177
172
const event: LoggerEvent = {
178
173
events: this.events,
174
+
id,
179
175
name,
180
176
start,
181
177
};