1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseAndBuildModel = exports.requestAndBuildModel = void 0;
const dependencies_1 = require("../dependencies");
const optional_1 = require("../types/optional");
const fetch_timing_metrics_builder_1 = require("./fetch-timing-metrics-builder");
/**
* Returns an object graph guaranteed to have a `FetchTimingMetricsBuilder` object.
*
* If a `FetchTimingMetricsBuilder` already exists, the same object graph is returned.
*
* If it doesn't exist, a new object graph is returned, which has a new `FetchTimingMetricsBuilder` added to it.
*/
function ensureFetchTimingMetricsBuilderExists(objectGraph, errorIfNotFound) {
const optionalBuilder = objectGraph.optional(fetch_timing_metrics_builder_1.fetchTimingMetricsBuilderType);
if ((0, optional_1.isSome)(optionalBuilder)) {
return objectGraph;
}
else {
if (errorIfNotFound) {
throw new Error("Could not find FetchTimingMetricsBuilder in the object graph");
}
return objectGraph.adding(fetch_timing_metrics_builder_1.fetchTimingMetricsBuilderType, new fetch_timing_metrics_builder_1.FetchTimingMetricsBuilder());
}
}
/**
* Orchestrates the flow to make a network request and then build the view model,
* capturing timing points around the model building step, and then
* adding performance metrics data to the final result.
*
* **Important**
*
* When using this method, it is the responsibility of the `requester` to instrument the network times and parsing times
* using a `FetchTimingMetricsBuilder` which is in the object graph.
*
* A simplified implementation of a requester function might look like this:
```
import * as types from "@jet/environment/types/globals/types"
import { fetchTimingMetricsBuilderType } from "@jet/environment/metrics";
export async function requestFromAPI(request: FetchRequest, objectGraph: ObjectGraph): Promise<MyParsedModel> {
const net = inject(types.net, objectGraph);
const fetchResponse = await net.fetch(request);
const fetchTimingMetricsBuilder = inject(fetchTimingMetricsBuilderType, objectGraph);
return fetchTimingMetricsBuilder.measureParsing(fetchResponse, (response) => {
const parsedBody = JSON.parse(response.body);
return new MyParsedModel(parsedBody);
});
}
```
* This approach supports a common pattern in our adopters in which the code that coordinates the fetch of the network request
* is tightly coupled to the code which parses the response.
*
* For an alternative approach which includes orchestrating the parsing step, use `parseAndBuildModel()`.
*
* @param request - The request object to pass to the `requester` function.
* @param objectGraph - Object graph that can be used to pass data to the `requester` and `modelBuilder` steps.
* The object graph must contain a `FetchTimingMetricsBuilder` that the `requester` will use to collect network times and parsing times.
* @param requester - A function which can make a network request, and return a `ResponseType` which can be used by the `modelBuilder`.
* @param modelBuilder - A step that takes the output of the `requester` step, and builds the view model.
* This parameter supports both synchronous and asynchronous functions.
* @returns The view model.
*/
async function requestAndBuildModel(request, objectGraph, requester, modelBuilder) {
const modifiedObjectGraph = ensureFetchTimingMetricsBuilderExists(objectGraph, true);
const response = await requester(request, modifiedObjectGraph);
return await constructAndDecorateModel(response, modifiedObjectGraph, modelBuilder);
}
exports.requestAndBuildModel = requestAndBuildModel;
/**
* Orchestrates the flow to parse a `FetchResponse` and then build the view model,
* adding performance metrics data to the final result.
*
* Timing points are captured around the parsing and model building steps,
* and this is added to the metrics which were returned from the `FetchResponse`.
*
* When using this method, it is the responsibility of the caller
* to perform the network fetch in order to have a `FetchResponse` object.
* The parsing logic which transforms the `FetchResponse` object into an intermediate model object
* will need to be decoupled so that it can be implemented in the `parser` function.
*
* @param response - The response from a `Network.fetch()` call.
* @param objectGraph - Object graph that can be used to pass data to the `parser` and `renderer` steps.
* @param parser - A step that parses a `FetchResponse` to an intermediate model object.
* @param modelBuilder - A step that takes the output of the `parser` step, and builds the view model.
* This parameter supports both synchronous and asynchronous functions.
* @returns The view model.
*/
async function parseAndBuildModel(response, objectGraph, parser, modelBuilder) {
const modifiedObjectGraph = ensureFetchTimingMetricsBuilderExists(objectGraph, false);
const fetchTimingMetricsBuilder = (0, dependencies_1.inject)(fetch_timing_metrics_builder_1.fetchTimingMetricsBuilderType, modifiedObjectGraph);
// Add metrics from FetchResponse, and run the parser, capturing timing points.
const parsedObject = fetchTimingMetricsBuilder.measureParsing(response, () => {
return parser(response, modifiedObjectGraph);
});
if ((0, optional_1.isNothing)(parsedObject)) {
throw new Error("parser function returned null or undefined");
}
return await constructAndDecorateModel(parsedObject, modifiedObjectGraph, modelBuilder);
}
exports.parseAndBuildModel = parseAndBuildModel;
async function constructAndDecorateModel(parsedObject, objectGraph, modelBuilder) {
const fetchTimingMetricsBuilder = (0, dependencies_1.inject)(fetch_timing_metrics_builder_1.fetchTimingMetricsBuilderType, objectGraph);
// Run the model builder, capturing timing points.
const model = await fetchTimingMetricsBuilder.measureModelConstructionAsync(async () => {
const maybePromise = modelBuilder(parsedObject, objectGraph); // The actual model, or a Promise of the model.
return await Promise.resolve(maybePromise); // If it was promise, it will await until the promise is resolved.
});
if ((0, optional_1.isNothing)(model)) {
throw new Error("model builder function returned null or undefined");
}
// Decorate the final output with the metrics data.
fetchTimingMetricsBuilder.decorate(model);
return model;
}
//# sourceMappingURL=parse-and-build-model.js.map
|
