@isograph/react 0.5.0 → 0.5.1

package/dist/core/makeNetworkRequest.js

@@ -1,280 +1,196 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeMakeNetworkRequest = maybeMakeNetworkRequest;
-exports.retainQueryWithoutMakingNetworkRequest = retainQueryWithoutMakingNetworkRequest;
-exports.makeNetworkRequest = makeNetworkRequest;
-const cache_1 = require("./cache");
-const check_1 = require("./check");
-const componentCache_1 = require("./componentCache");
-const garbageCollection_1 = require("./garbageCollection");
-const IsographEnvironment_1 = require("./IsographEnvironment");
-const logging_1 = require("./logging");
-const optimisticProxy_1 = require("./optimisticProxy");
-const PromiseWrapper_1 = require("./PromiseWrapper");
-const read_1 = require("./read");
-const startUpdate_1 = require("./startUpdate");
+const require_PromiseWrapper = require('./PromiseWrapper.js');
+const require_IsographEnvironment = require('./IsographEnvironment.js');
+const require_logging = require('./logging.js');
+const require_startUpdate = require('./startUpdate.js');
+const require_componentCache = require('./componentCache.js');
+const require_check = require('./check.js');
+const require_read = require('./read.js');
+const require_subscribe = require('./subscribe.js');
+const require_optimisticProxy = require('./optimisticProxy.js');
+const require_cache = require('./cache.js');
+const require_garbageCollection = require('./garbageCollection.js');
+
+//#region src/core/makeNetworkRequest.ts
 let networkRequestId = 0;
 function maybeMakeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions) {
-    var _a;
-    switch ((_a = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.shouldFetch) !== null && _a !== void 0 ? _a : check_1.DEFAULT_SHOULD_FETCH_VALUE) {
-        case 'Yes': {
-            return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
-        }
-        case 'No': {
-            return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
-        }
-        case 'IfNecessary': {
-            if (artifact.networkRequestInfo.normalizationAst.kind ===
-                'NormalizationAstLoader') {
-                throw new Error('Using lazy loaded normalizationAst with shouldFetch: "IfNecessary" is ' +
-                    'not supported as it will lead to a network waterfall.');
-            }
-            const result = (0, check_1.check)(environment, artifact.networkRequestInfo.normalizationAst.selections, variables, {
-                __link: IsographEnvironment_1.ROOT_ID,
-                __typename: artifact.concreteType,
-            });
-            if (result.kind === 'EnoughData') {
-                return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
-            }
-            else {
-                return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
-            }
-        }
-    }
+	switch (fetchOptions?.shouldFetch ?? require_check.DEFAULT_SHOULD_FETCH_VALUE) {
+		case "Yes": return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
+		case "No": return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
+		case "IfNecessary":
+			if (artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAstLoader") throw new Error("Using lazy loaded normalizationAst with shouldFetch: \"IfNecessary\" is not supported as it will lead to a network waterfall.");
+			if (require_check.check(environment, artifact.networkRequestInfo.normalizationAst.selections, variables, {
+				__link: require_IsographEnvironment.ROOT_ID,
+				__typename: artifact.concreteType
+			}).kind === "EnoughData") return retainQueryWithoutMakingNetworkRequest(environment, artifact, variables);
+			else return makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions);
+	}
 }
 function retainQueryWithoutMakingNetworkRequest(environment, artifact, variables) {
-    let status = {
-        kind: 'UndisposedComplete',
-        retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables),
-    };
-    return [
-        (0, PromiseWrapper_1.wrapResolvedValue)(undefined),
-        () => {
-            if (status.kind !== 'Disposed') {
-                status = unretainAndGarbageCollect(environment, status);
-            }
-        },
-    ];
+	let status = {
+		kind: "UndisposedComplete",
+		retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables)
+	};
+	return [require_PromiseWrapper.wrapResolvedValue(void 0), () => {
+		if (status.kind !== "Disposed") status = unretainAndGarbageCollect(environment, status);
+	}];
 }
 function makeNetworkRequest(environment, artifact, variables, readerWithRefetchQueries, fetchOptions) {
-    // TODO this should be a DataId and stored in the store
-    const myNetworkRequestId = networkRequestId + '';
-    networkRequestId++;
-    let status = {
-        kind: 'UndisposedIncomplete',
-        retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables),
-        optimistic: (fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.optimisticNetworkResponse) != null
-            ? makeOptimisticUpdate(environment, artifact, variables, fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.optimisticNetworkResponse)
-            : null,
-    };
-    (0, logging_1.logMessage)(environment, () => ({
-        kind: 'MakeNetworkRequest',
-        artifact,
-        variables,
-        networkRequestId: myNetworkRequestId,
-    }));
-    // This should be an observable, not a promise
-    const promise = Promise.all([
-        environment.networkFunction(artifact.networkRequestInfo.operation, variables),
-        status.retainedQuery.normalizationAst.promise,
-        readerWithRefetchQueries === null || readerWithRefetchQueries === void 0 ? void 0 : readerWithRefetchQueries.promise,
-    ])
-        .then(([networkResponse, normalizationAst, readerWithRefetchQueries]) => {
-        var _a, _b;
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'ReceivedNetworkResponse',
-            networkResponse,
-            networkRequestId: myNetworkRequestId,
-        }));
-        if (networkResponse.errors != null) {
-            try {
-                (_a = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.onError) === null || _a === void 0 ? void 0 : _a.call(fetchOptions);
-            }
-            catch (_c) { }
-            throw new Error('Network response had errors', {
-                cause: networkResponse,
-            });
-        }
-        const root = { __link: IsographEnvironment_1.ROOT_ID, __typename: artifact.concreteType };
-        if (status.kind === 'UndisposedIncomplete') {
-            if (status.optimistic != null) {
-                status =
-                    revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, (storeLayer) => {
-                        var _a;
-                        return (0, cache_1.normalizeData)(environment, storeLayer, normalizationAst.selections, (_a = networkResponse.data) !== null && _a !== void 0 ? _a : {}, variables, root, new Map());
-                    });
-            }
-            else {
-                const encounteredIds = new Map();
-                environment.store = (0, optimisticProxy_1.addNetworkResponseStoreLayer)(environment.store);
-                (0, cache_1.normalizeData)(environment, environment.store, normalizationAst.selections, (_b = networkResponse.data) !== null && _b !== void 0 ? _b : {}, variables, root, encounteredIds);
-                (0, logging_1.logMessage)(environment, () => ({
-                    kind: 'AfterNormalization',
-                    store: environment.store,
-                    encounteredIds: encounteredIds,
-                }));
-                (0, cache_1.callSubscriptions)(environment, encounteredIds);
-                status = {
-                    kind: 'UndisposedComplete',
-                    retainedQuery: status.retainedQuery,
-                };
-            }
-        }
-        const onComplete = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.onComplete;
-        if (onComplete != null) {
-            let data = readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries);
-            try {
-                // @ts-expect-error this problem will be fixed when we remove RefetchQueryNormalizationArtifact
-                // (or we can fix this by having a single param of type { kind: 'Entrypoint', entrypoint,
-                // fetchOptions: FetchOptions<TReadFromStore> } | { kind: 'RefetchQuery', refetchQuery,
-                // fetchOptions: FetchOptions<void> }).
-                onComplete(data);
-            }
-            catch (_d) { }
-        }
-    })
-        .catch((e) => {
-        var _a;
-        (0, logging_1.logMessage)(environment, () => ({
-            kind: 'ReceivedNetworkError',
-            networkRequestId: myNetworkRequestId,
-            error: e,
-        }));
-        try {
-            (_a = fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.onError) === null || _a === void 0 ? void 0 : _a.call(fetchOptions);
-        }
-        catch (_b) { }
-        if (status.kind === 'UndisposedIncomplete') {
-            status =
-                revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
-        }
-        throw e;
-    });
-    const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
-    const response = [
-        wrapper,
-        () => {
-            if (status.kind === 'UndisposedIncomplete') {
-                status =
-                    revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
-            }
-            if (status.kind !== 'Disposed') {
-                status = unretainAndGarbageCollect(environment, status);
-            }
-        },
-    ];
-    return response;
+	const myNetworkRequestId = networkRequestId + "";
+	networkRequestId++;
+	let status = {
+		kind: "UndisposedIncomplete",
+		retainedQuery: fetchNormalizationAstAndRetainArtifact(environment, artifact, variables),
+		optimistic: fetchOptions?.optimisticNetworkResponse != null ? makeOptimisticUpdate(environment, artifact, variables, fetchOptions?.optimisticNetworkResponse) : null
+	};
+	require_logging.logMessage(environment, () => ({
+		kind: "MakeNetworkRequest",
+		artifact,
+		variables,
+		networkRequestId: myNetworkRequestId
+	}));
+	return [require_PromiseWrapper.wrapPromise(Promise.all([
+		environment.networkFunction(artifact.networkRequestInfo.operation, variables),
+		status.retainedQuery.normalizationAst.promise,
+		readerWithRefetchQueries?.promise
+	]).then(([networkResponse, normalizationAst, readerWithRefetchQueries$1]) => {
+		require_logging.logMessage(environment, () => ({
+			kind: "ReceivedNetworkResponse",
+			networkResponse,
+			networkRequestId: myNetworkRequestId
+		}));
+		if (networkResponse.errors != null) {
+			try {
+				fetchOptions?.onError?.();
+			} catch {}
+			throw new Error("Network response had errors", { cause: networkResponse });
+		}
+		const root = {
+			__link: require_IsographEnvironment.ROOT_ID,
+			__typename: artifact.concreteType
+		};
+		if (status.kind === "UndisposedIncomplete") if (status.optimistic != null) status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, (storeLayer) => require_cache.normalizeData(environment, storeLayer, normalizationAst.selections, networkResponse.data ?? {}, variables, root, /* @__PURE__ */ new Map()));
+		else {
+			const encounteredIds = /* @__PURE__ */ new Map();
+			environment.store = require_optimisticProxy.addNetworkResponseStoreLayer(environment.store);
+			require_cache.normalizeData(environment, environment.store, normalizationAst.selections, networkResponse.data ?? {}, variables, root, encounteredIds);
+			require_logging.logMessage(environment, () => ({
+				kind: "AfterNormalization",
+				store: environment.store,
+				encounteredIds
+			}));
+			require_subscribe.callSubscriptions(environment, encounteredIds);
+			status = {
+				kind: "UndisposedComplete",
+				retainedQuery: status.retainedQuery
+			};
+		}
+		const onComplete = fetchOptions?.onComplete;
+		if (onComplete != null) {
+			let data = readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries$1);
+			try {
+				onComplete(data);
+			} catch {}
+		}
+	}).catch((e) => {
+		require_logging.logMessage(environment, () => ({
+			kind: "ReceivedNetworkError",
+			networkRequestId: myNetworkRequestId,
+			error: e
+		}));
+		try {
+			fetchOptions?.onError?.();
+		} catch {}
+		if (status.kind === "UndisposedIncomplete") status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
+		throw e;
+	})), () => {
+		if (status.kind === "UndisposedIncomplete") status = revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, null);
+		if (status.kind !== "Disposed") status = unretainAndGarbageCollect(environment, status);
+	}];
 }
 function readDataForOnComplete(artifact, environment, root, variables, readerWithRefetchQueries) {
-    // An entrypoint, but not a RefetchQueryNormalizationArtifact, has a reader ASTs.
-    // So, we can only pass data to onComplete if makeNetworkRequest was passed an entrypoint.
-    // This is awkward, since we don't express that in the types of the parameters
-    // (i.e. FetchOptions could be passed, along with a RefetchQueryNormalizationArtifact).
-    //
-    // However, this isn't a big deal: RefetchQueryNormalizationArtifact is going away.
-    if (artifact.kind === 'Entrypoint') {
-        // TODO this is a smell!
-        const fakeNetworkRequest = (0, PromiseWrapper_1.wrapResolvedValue)(undefined);
-        // TODO this is a smell — we know the network response is not in flight,
-        // so we don't really care!
-        const fakeNetworkRequestOptions = {
-            suspendIfInFlight: false,
-            throwOnNetworkError: false,
-        };
-        const resolvedReaderWithRefetchQueries = readerWithRefetchQueries;
-        const fragment = {
-            kind: 'FragmentReference',
-            // TODO this smells.
-            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)(resolvedReaderWithRefetchQueries),
-            fieldName: resolvedReaderWithRefetchQueries.readerArtifact.fieldName,
-            readerArtifactKind: resolvedReaderWithRefetchQueries.readerArtifact.kind,
-            root,
-            variables,
-            networkRequest: fakeNetworkRequest,
-        };
-        const fragmentResult = (0, read_1.readButDoNotEvaluate)(environment, fragment, fakeNetworkRequestOptions).item;
-        const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
-        switch (readerArtifact.kind) {
-            case 'ComponentReaderArtifact': {
-                // @ts-expect-error We should find a way to encode this in the type system:
-                // if we have a ComponentReaderArtifact, we will necessarily have a
-                // TClientFieldValue which is a React.FC<...>
-                return (0, componentCache_1.getOrCreateCachedComponent)(environment, {
-                    kind: 'FragmentReference',
-                    readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
-                        kind: 'ReaderWithRefetchQueries',
-                        readerArtifact: readerArtifact,
-                        nestedRefetchQueries: resolvedReaderWithRefetchQueries.nestedRefetchQueries,
-                    }),
-                    fieldName: readerArtifact.fieldName,
-                    readerArtifactKind: readerArtifact.kind,
-                    root,
-                    variables,
-                    networkRequest: fakeNetworkRequest,
-                }, fakeNetworkRequestOptions);
-            }
-            case 'EagerReaderArtifact': {
-                return readerArtifact.resolver(Object.assign({ data: fragmentResult, parameters: variables }, (readerArtifact.hasUpdatable
-                    ? {
-                        startUpdate: (0, startUpdate_1.getOrCreateCachedStartUpdate)(environment, fragment, fakeNetworkRequestOptions),
-                    }
-                    : undefined)));
-            }
-            default: {
-                const _ = readerArtifact;
-                _;
-                throw new Error('Expected case');
-            }
-        }
-    }
-    return null;
+	if (artifact.kind === "Entrypoint") {
+		const fakeNetworkRequest = require_PromiseWrapper.wrapResolvedValue(void 0);
+		const fakeNetworkRequestOptions = {
+			suspendIfInFlight: false,
+			throwOnNetworkError: false
+		};
+		const resolvedReaderWithRefetchQueries = readerWithRefetchQueries;
+		const fragment = {
+			kind: "FragmentReference",
+			readerWithRefetchQueries: require_PromiseWrapper.wrapResolvedValue(resolvedReaderWithRefetchQueries),
+			fieldName: resolvedReaderWithRefetchQueries.readerArtifact.fieldName,
+			readerArtifactKind: resolvedReaderWithRefetchQueries.readerArtifact.kind,
+			root,
+			variables,
+			networkRequest: fakeNetworkRequest
+		};
+		const fragmentResult = require_read.readButDoNotEvaluate(environment, fragment, fakeNetworkRequestOptions).item;
+		const readerArtifact = resolvedReaderWithRefetchQueries.readerArtifact;
+		switch (readerArtifact.kind) {
+			case "ComponentReaderArtifact": return require_componentCache.getOrCreateCachedComponent(environment, {
+				kind: "FragmentReference",
+				readerWithRefetchQueries: require_PromiseWrapper.wrapResolvedValue({
+					kind: "ReaderWithRefetchQueries",
+					readerArtifact,
+					nestedRefetchQueries: resolvedReaderWithRefetchQueries.nestedRefetchQueries
+				}),
+				fieldName: readerArtifact.fieldName,
+				readerArtifactKind: readerArtifact.kind,
+				root,
+				variables,
+				networkRequest: fakeNetworkRequest
+			}, fakeNetworkRequestOptions);
+			case "EagerReaderArtifact": return readerArtifact.resolver({
+				data: fragmentResult,
+				parameters: variables,
+				...readerArtifact.hasUpdatable ? { startUpdate: require_startUpdate.getOrCreateCachedStartUpdate(environment, fragment, fakeNetworkRequestOptions) } : void 0
+			});
+		}
+	}
+	return null;
 }
 function fetchNormalizationAstAndRetainArtifact(environment, artifact, variables) {
-    const normalizationAst = artifact.networkRequestInfo.normalizationAst.kind === 'NormalizationAst'
-        ? (0, PromiseWrapper_1.wrapResolvedValue)(artifact.networkRequestInfo.normalizationAst)
-        : (0, PromiseWrapper_1.wrapPromise)(artifact.networkRequestInfo.normalizationAst.loader());
-    const root = { __link: IsographEnvironment_1.ROOT_ID, __typename: artifact.concreteType };
-    const retainedQuery = {
-        normalizationAst: normalizationAst,
-        variables,
-        root,
-    };
-    (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
-    return retainedQuery;
+	const retainedQuery = {
+		normalizationAst: artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAst" ? require_PromiseWrapper.wrapResolvedValue(artifact.networkRequestInfo.normalizationAst) : require_PromiseWrapper.wrapPromise(artifact.networkRequestInfo.normalizationAst.loader()),
+		variables,
+		root: {
+			__link: require_IsographEnvironment.ROOT_ID,
+			__typename: artifact.concreteType
+		}
+	};
+	require_garbageCollection.retainQuery(environment, retainedQuery);
+	return retainedQuery;
 }
 function makeOptimisticUpdate(environment, artifact, variables, optimisticNetworkResponse) {
-    const root = { __link: IsographEnvironment_1.ROOT_ID, __typename: artifact.concreteType };
-    if (artifact.networkRequestInfo.normalizationAst.kind ===
-        'NormalizationAstLoader') {
-        throw new Error('Using lazy loaded normalizationAst with optimisticNetworkResponse is not supported.');
-    }
-    const encounteredIds = new Map();
-    const optimistic = (environment.store =
-        (0, optimisticProxy_1.addOptimisticNetworkResponseStoreLayer)(environment.store));
-    (0, cache_1.normalizeData)(environment, environment.store, artifact.networkRequestInfo.normalizationAst.selections, optimisticNetworkResponse, variables, root, encounteredIds);
-    (0, logging_1.logMessage)(environment, () => ({
-        kind: 'AfterNormalization',
-        store: environment.store,
-        encounteredIds: encounteredIds,
-    }));
-    (0, cache_1.callSubscriptions)(environment, encounteredIds);
-    return optimistic;
+	const root = {
+		__link: require_IsographEnvironment.ROOT_ID,
+		__typename: artifact.concreteType
+	};
+	if (artifact.networkRequestInfo.normalizationAst.kind === "NormalizationAstLoader") throw new Error("Using lazy loaded normalizationAst with optimisticNetworkResponse is not supported.");
+	const encounteredIds = /* @__PURE__ */ new Map();
+	const optimistic = environment.store = require_optimisticProxy.addOptimisticNetworkResponseStoreLayer(environment.store);
+	require_cache.normalizeData(environment, environment.store, artifact.networkRequestInfo.normalizationAst.selections, optimisticNetworkResponse, variables, root, encounteredIds);
+	require_logging.logMessage(environment, () => ({
+		kind: "AfterNormalization",
+		store: environment.store,
+		encounteredIds
+	}));
+	require_subscribe.callSubscriptions(environment, encounteredIds);
+	return optimistic;
 }
-function revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, normalizeData) {
-    if (status.optimistic) {
-        (0, optimisticProxy_1.revertOptimisticStoreLayerAndMaybeReplace)(environment, status.optimistic, normalizeData);
-    }
-    return {
-        kind: 'UndisposedComplete',
-        retainedQuery: status.retainedQuery,
-    };
+function revertOptimisticStoreLayerAndMaybeReplaceIfUndisposedIncomplete(environment, status, normalizeData$1) {
+	if (status.optimistic != null) require_optimisticProxy.revertOptimisticStoreLayerAndMaybeReplace(environment, status.optimistic, normalizeData$1);
+	return {
+		kind: "UndisposedComplete",
+		retainedQuery: status.retainedQuery
+	};
 }
 function unretainAndGarbageCollect(environment, status) {
-    const didUnretainSomeQuery = (0, garbageCollection_1.unretainQuery)(environment, status.retainedQuery);
-    if (didUnretainSomeQuery) {
-        (0, garbageCollection_1.garbageCollectEnvironment)(environment);
-    }
-    return {
-        kind: 'Disposed',
-    };
+	if (require_garbageCollection.unretainQuery(environment, status.retainedQuery)) require_garbageCollection.garbageCollectEnvironment(environment);
+	return { kind: "Disposed" };
 }
+
+//#endregion
+exports.makeNetworkRequest = makeNetworkRequest;
+exports.maybeMakeNetworkRequest = maybeMakeNetworkRequest;
+exports.retainQueryWithoutMakingNetworkRequest = retainQueryWithoutMakingNetworkRequest;