@isograph/react 0.1.0 → 0.2.0

package/dist/core/makeNetworkRequest.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNetworkRequest = void 0;
+const garbageCollection_1 = require("./garbageCollection");
+const PromiseWrapper_1 = require("./PromiseWrapper");
+const cache_1 = require("./cache");
+function makeNetworkRequest(environment, artifact, variables) {
+    // @ts-expect-error
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('make network request', artifact, variables);
+    }
+    let status = {
+        kind: 'UndisposedIncomplete',
+    };
+    // This should be an observable, not a promise
+    const promise = environment
+        .networkFunction(artifact.queryText, variables)
+        .then((networkResponse) => {
+        var _a;
+        // @ts-expect-error
+        if (typeof window !== 'undefined' && window.__LOG) {
+            console.log('network response', artifact, networkResponse);
+        }
+        if (networkResponse.errors != null) {
+            // @ts-expect-error Why are we getting the wrong constructor here?
+            throw new Error('GraphQL network response had errors', {
+                cause: networkResponse,
+            });
+        }
+        if (status.kind === 'UndisposedIncomplete') {
+            (0, cache_1.normalizeData)(environment, artifact.normalizationAst, (_a = networkResponse.data) !== null && _a !== void 0 ? _a : {}, variables, artifact.kind === 'Entrypoint'
+                ? artifact.readerWithRefetchQueries.nestedRefetchQueries
+                : []);
+            const retainedQuery = {
+                normalizationAst: artifact.normalizationAst,
+                variables,
+            };
+            status = {
+                kind: 'UndisposedComplete',
+                retainedQuery,
+            };
+            (0, garbageCollection_1.retainQuery)(environment, retainedQuery);
+        }
+    });
+    const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
+    const response = [
+        wrapper,
+        () => {
+            if (status.kind === 'UndisposedComplete') {
+                const didUnretainSomeQuery = (0, garbageCollection_1.unretainQuery)(environment, status.retainedQuery);
+                if (didUnretainSomeQuery) {
+                    (0, garbageCollection_1.garbageCollectEnvironment)(environment);
+                }
+            }
+            status = {
+                kind: 'Disposed',
+            };
+        },
+    ];
+    return response;
+}
+exports.makeNetworkRequest = makeNetworkRequest;

package/dist/core/read.d.ts

@@ -0,0 +1,12 @@
+import { FragmentReference } from './FragmentReference';
+import { DataId, IsographEnvironment } from './IsographEnvironment';
+export type WithEncounteredRecords<T> = {
+    readonly encounteredRecords: Set<DataId>;
+    readonly item: T;
+};
+export declare function readButDoNotEvaluate<TReadFromStore extends Object>(environment: IsographEnvironment, fragmentReference: FragmentReference<TReadFromStore, unknown>, networkRequestOptions: NetworkRequestReaderOptions): WithEncounteredRecords<TReadFromStore>;
+export type NetworkRequestReaderOptions = {
+    suspendIfInFlight: boolean;
+    throwOnNetworkError: boolean;
+};
+export declare function getNetworkRequestOptionsWithDefaults(networkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): NetworkRequestReaderOptions;

package/dist/core/read.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNetworkRequestOptionsWithDefaults = exports.readButDoNotEvaluate = void 0;
+const cache_1 = require("./cache");
+const componentCache_1 = require("./componentCache");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+const makeNetworkRequest_1 = require("./makeNetworkRequest");
+const PromiseWrapper_1 = require("./PromiseWrapper");
+function readButDoNotEvaluate(environment, fragmentReference, networkRequestOptions) {
+    var _a;
+    const mutableEncounteredRecords = new Set();
+    const readerWithRefetchQueries = (0, PromiseWrapper_1.readPromise)(fragmentReference.readerWithRefetchQueries);
+    const response = readData(environment, readerWithRefetchQueries.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, readerWithRefetchQueries.nestedRefetchQueries, fragmentReference.networkRequest, networkRequestOptions, mutableEncounteredRecords);
+    // @ts-expect-error
+    if (typeof window !== 'undefined' && window.__LOG) {
+        console.log('done reading', { response });
+    }
+    if (response.kind === 'MissingData') {
+        // There are two cases here that we care about:
+        // 1. the network request is in flight, we haven't suspend on it, and we want
+        //    to throw if it errors out. So, networkRequestOptions.suspendIfInFlight === false
+        //    and networkRequestOptions.throwOnNetworkError === true.
+        // 2. everything else
+        //
+        // In the first case, we cannot simply throw onNextChange, because if the network
+        // response errors out, we will not update the store, so the onNextChange promise
+        // will not resolve.
+        if (!networkRequestOptions.suspendIfInFlight &&
+            networkRequestOptions.throwOnNetworkError) {
+            // TODO assert that the network request state is not Err
+            throw new Promise((resolve, reject) => {
+                (0, cache_1.onNextChange)(environment).then(resolve);
+                fragmentReference.networkRequest.promise.catch(reject);
+            });
+        }
+        throw (0, cache_1.onNextChange)(environment);
+    }
+    else {
+        return {
+            encounteredRecords: mutableEncounteredRecords,
+            item: response.data,
+        };
+    }
+}
+exports.readButDoNotEvaluate = readButDoNotEvaluate;
+function readData(environment, ast, root, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords) {
+    var _a, _b, _c, _d, _e;
+    mutableEncounteredRecords.add(root);
+    let storeRecord = environment.store[root];
+    if (storeRecord === undefined) {
+        return {
+            kind: 'MissingData',
+            reason: 'No record for root ' + root,
+        };
+    }
+    if (storeRecord === null) {
+        return {
+            kind: 'Success',
+            data: null,
+            encounteredRecords: mutableEncounteredRecords,
+        };
+    }
+    let target = {};
+    for (const field of ast) {
+        switch (field.kind) {
+            case 'Scalar': {
+                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
+                const value = storeRecord[storeRecordName];
+                // TODO consider making scalars into discriminated unions. This probably has
+                // to happen for when we handle errors.
+                if (value === undefined) {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'No value for ' + storeRecordName + ' on root ' + root,
+                    };
+                }
+                target[(_a = field.alias) !== null && _a !== void 0 ? _a : field.fieldName] = value;
+                break;
+            }
+            case 'Linked': {
+                const storeRecordName = (0, cache_1.getParentRecordKey)(field, variables);
+                const value = storeRecord[storeRecordName];
+                if (Array.isArray(value)) {
+                    const results = [];
+                    for (const item of value) {
+                        const link = (0, IsographEnvironment_1.assertLink)(item);
+                        if (link === undefined) {
+                            return {
+                                kind: 'MissingData',
+                                reason: 'No link for ' +
+                                    storeRecordName +
+                                    ' on root ' +
+                                    root +
+                                    '. Link is ' +
+                                    JSON.stringify(item),
+                            };
+                        }
+                        else if (link === null) {
+                            results.push(null);
+                            continue;
+                        }
+                        const result = readData(environment, field.selections, link.__link, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                        if (result.kind === 'MissingData') {
+                            return {
+                                kind: 'MissingData',
+                                reason: 'Missing data for ' +
+                                    storeRecordName +
+                                    ' on root ' +
+                                    root +
+                                    '. Link is ' +
+                                    JSON.stringify(item),
+                                nestedReason: result,
+                            };
+                        }
+                        results.push(result.data);
+                    }
+                    target[(_b = field.alias) !== null && _b !== void 0 ? _b : field.fieldName] = results;
+                    break;
+                }
+                let link = (0, IsographEnvironment_1.assertLink)(value);
+                if (link === undefined) {
+                    // TODO make this configurable, and also generated and derived from the schema
+                    const missingFieldHandler = (_c = environment.missingFieldHandler) !== null && _c !== void 0 ? _c : IsographEnvironment_1.defaultMissingFieldHandler;
+                    const altLink = missingFieldHandler(storeRecord, root, field.fieldName, field.arguments, variables);
+                    if (altLink === undefined) {
+                        return {
+                            kind: 'MissingData',
+                            reason: 'No link for ' +
+                                storeRecordName +
+                                ' on root ' +
+                                root +
+                                '. Link is ' +
+                                JSON.stringify(value),
+                        };
+                    }
+                    else {
+                        link = altLink;
+                    }
+                }
+                else if (link === null) {
+                    target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = null;
+                    break;
+                }
+                const targetId = link.__link;
+                const data = readData(environment, field.selections, targetId, variables, nestedRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                if (data.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + storeRecordName + ' on root ' + root,
+                        nestedReason: data,
+                    };
+                }
+                target[(_e = field.alias) !== null && _e !== void 0 ? _e : field.fieldName] = data.data;
+                break;
+            }
+            case 'ImperativelyLoadedField': {
+                // First, we read the data using the refetch reader AST (i.e. read out the
+                // id field).
+                const data = readData(environment, field.refetchReaderArtifact.readerAst, root, variables, 
+                // Refetch fields just read the id, and don't need refetch query artifacts
+                [], 
+                // This is probably indicative of the fact that we are doing redundant checks
+                // on the status of this network request...
+                networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                if (data.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                        nestedReason: data,
+                    };
+                }
+                else {
+                    const refetchQueryIndex = field.refetchQuery;
+                    if (refetchQueryIndex == null) {
+                        throw new Error('refetchQuery is null in RefetchField');
+                    }
+                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+                    const refetchQueryArtifact = refetchQuery.artifact;
+                    const allowedVariables = refetchQuery.allowedVariables;
+                    // Second, we allow the user to call the resolver, which will ultimately
+                    // use the resolver reader AST to get the resolver parameters.
+                    target[field.alias] = (args) => [
+                        // Stable id
+                        root + '__' + field.name,
+                        // Fetcher
+                        field.refetchReaderArtifact.resolver(environment, refetchQueryArtifact, data.data, filterVariables(Object.assign(Object.assign({}, args), variables), allowedVariables), root, 
+                        // TODO these params should be removed
+                        null, []),
+                    ];
+                }
+                break;
+            }
+            case 'Resolver': {
+                const usedRefetchQueries = field.usedRefetchQueries;
+                const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
+                switch (field.readerArtifact.kind) {
+                    case 'EagerReaderArtifact': {
+                        const data = readData(environment, field.readerArtifact.readerAst, root, variables, resolverRefetchQueries, networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                        if (data.kind === 'MissingData') {
+                            return {
+                                kind: 'MissingData',
+                                reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                                nestedReason: data,
+                            };
+                        }
+                        else {
+                            target[field.alias] = field.readerArtifact.resolver(data.data);
+                        }
+                        break;
+                    }
+                    case 'ComponentReaderArtifact': {
+                        target[field.alias] = (0, componentCache_1.getOrCreateCachedComponent)(environment, field.readerArtifact.componentName, {
+                            kind: 'FragmentReference',
+                            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
+                                kind: 'ReaderWithRefetchQueries',
+                                readerArtifact: field.readerArtifact,
+                                nestedRefetchQueries: resolverRefetchQueries,
+                            }),
+                            root,
+                            variables: generateChildVariableMap(variables, field.arguments),
+                            networkRequest,
+                        }, networkRequestOptions);
+                        break;
+                    }
+                    default: {
+                        let _ = field.readerArtifact;
+                        _;
+                        throw new Error('Unexpected kind');
+                    }
+                }
+                break;
+            }
+            case 'LoadablySelectedField': {
+                const refetchReaderParams = readData(environment, field.refetchReaderAst, root, variables, 
+                // Refetch fields just read the id, and don't need refetch query artifacts
+                [], networkRequest, networkRequestOptions, mutableEncounteredRecords);
+                if (refetchReaderParams.kind === 'MissingData') {
+                    return {
+                        kind: 'MissingData',
+                        reason: 'Missing data for ' + field.alias + ' on root ' + root,
+                        nestedReason: refetchReaderParams,
+                    };
+                }
+                else {
+                    target[field.alias] = (args) => {
+                        // TODO we should use the reader AST for this
+                        const includeReadOutData = (variables, readOutData) => {
+                            variables.id = readOutData.id;
+                            return variables;
+                        };
+                        const localVariables = includeReadOutData(args !== null && args !== void 0 ? args : {}, refetchReaderParams.data);
+                        writeQueryArgsToVariables(localVariables, field.queryArguments, variables);
+                        return [
+                            // Stable id
+                            root +
+                                '/' +
+                                field.name +
+                                '/' +
+                                stableStringifyArgs(localVariables),
+                            // Fetcher
+                            () => {
+                                const fragmentReferenceAndDisposeFromEntrypoint = (entrypoint) => {
+                                    const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, localVariables);
+                                    const fragmentReference = {
+                                        kind: 'FragmentReference',
+                                        readerWithRefetchQueries: (0, PromiseWrapper_1.wrapResolvedValue)({
+                                            kind: 'ReaderWithRefetchQueries',
+                                            readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
+                                            nestedRefetchQueries: entrypoint.readerWithRefetchQueries
+                                                .nestedRefetchQueries,
+                                        }),
+                                        // TODO localVariables is not guaranteed to have an id field
+                                        root: localVariables.id,
+                                        variables: localVariables,
+                                        networkRequest,
+                                    };
+                                    return [fragmentReference, disposeNetworkRequest];
+                                };
+                                if (field.entrypoint.kind === 'Entrypoint') {
+                                    return fragmentReferenceAndDisposeFromEntrypoint(field.entrypoint);
+                                }
+                                else {
+                                    const isographArtifactPromiseWrapper = (0, IsographEnvironment_1.getOrLoadIsographArtifact)(environment, field.entrypoint.typeAndField, field.entrypoint.loader);
+                                    const state = (0, PromiseWrapper_1.getPromiseState)(isographArtifactPromiseWrapper);
+                                    if (state.kind === 'Ok') {
+                                        return fragmentReferenceAndDisposeFromEntrypoint(state.value);
+                                    }
+                                    else {
+                                        // Promise is pending or thrown
+                                        let entrypointLoaderState = { kind: 'EntrypointNotLoaded' };
+                                        const networkRequest = (0, PromiseWrapper_1.wrapPromise)(isographArtifactPromiseWrapper.promise.then((entrypoint) => {
+                                            if (entrypointLoaderState.kind === 'EntrypointNotLoaded') {
+                                                const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, localVariables);
+                                                entrypointLoaderState = {
+                                                    kind: 'NetworkRequestStarted',
+                                                    disposeNetworkRequest,
+                                                };
+                                                return networkRequest.promise;
+                                            }
+                                        }));
+                                        const readerWithRefetchPromise = isographArtifactPromiseWrapper.promise.then((entrypoint) => entrypoint.readerWithRefetchQueries);
+                                        const fragmentReference = {
+                                            kind: 'FragmentReference',
+                                            readerWithRefetchQueries: (0, PromiseWrapper_1.wrapPromise)(readerWithRefetchPromise),
+                                            // TODO localVariables is not guaranteed to have an id field
+                                            root: localVariables.id,
+                                            variables: localVariables,
+                                            networkRequest,
+                                        };
+                                        return [
+                                            fragmentReference,
+                                            () => {
+                                                if (entrypointLoaderState.kind === 'NetworkRequestStarted') {
+                                                    entrypointLoaderState.disposeNetworkRequest();
+                                                }
+                                                entrypointLoaderState = { kind: 'Disposed' };
+                                            },
+                                        ];
+                                    }
+                                }
+                            },
+                        ];
+                    };
+                }
+                break;
+            }
+            default: {
+                // Ensure we have covered all variants
+                let _ = field;
+                _;
+                throw new Error('Unexpected case.');
+            }
+        }
+    }
+    return {
+        kind: 'Success',
+        data: target,
+        encounteredRecords: mutableEncounteredRecords,
+    };
+}
+function filterVariables(variables, allowedVariables) {
+    const result = {};
+    for (const key of allowedVariables) {
+        // @ts-expect-error
+        result[key] = variables[key];
+    }
+    return result;
+}
+function generateChildVariableMap(variables, fieldArguments) {
+    if (fieldArguments == null) {
+        return {};
+    }
+    const childVars = {};
+    for (const [name, value] of fieldArguments) {
+        if (value.kind === 'Variable') {
+            childVars[name] = variables[value.name];
+        }
+        else {
+            childVars[name] = value.value;
+        }
+    }
+    return childVars;
+}
+function writeQueryArgsToVariables(targetVariables, queryArgs, variables) {
+    if (queryArgs == null) {
+        return;
+    }
+    for (const [name, argType] of queryArgs) {
+        switch (argType.kind) {
+            case 'Variable': {
+                targetVariables[name] = variables[argType.name];
+                break;
+            }
+            case 'Enum': {
+                targetVariables[name] = argType.value;
+                break;
+            }
+            case 'Literal': {
+                targetVariables[name] = argType.value;
+                break;
+            }
+            case 'String': {
+                targetVariables[name] = argType.value;
+                break;
+            }
+            default: {
+                const _ = argType;
+                _;
+                throw new Error('Unexpected case');
+            }
+        }
+    }
+}
+function getNetworkRequestOptionsWithDefaults(networkRequestOptions) {
+    var _a, _b;
+    return {
+        suspendIfInFlight: (_a = networkRequestOptions === null || networkRequestOptions === void 0 ? void 0 : networkRequestOptions.suspendIfInFlight) !== null && _a !== void 0 ? _a : false,
+        throwOnNetworkError: (_b = networkRequestOptions === null || networkRequestOptions === void 0 ? void 0 : networkRequestOptions.throwOnNetworkError) !== null && _b !== void 0 ? _b : true,
+    };
+}
+exports.getNetworkRequestOptionsWithDefaults = getNetworkRequestOptionsWithDefaults;
+// TODO use a description of the params for this?
+// TODO call stableStringifyArgs on the variable values, as well.
+// This doesn't matter for now, since we are just using primitive values
+// in the demo.
+function stableStringifyArgs(args) {
+    const keys = Object.keys(args);
+    keys.sort();
+    let s = '';
+    for (const key of keys) {
+        // @ts-expect-error
+        s += `${key}=${JSON.stringify(args[key])};`;
+    }
+    return s;
+}

package/dist/core/reader.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="react" />
+import { Factory } from '@isograph/disposable-types';
+import { FragmentReference } from './FragmentReference';
+import { ComponentOrFieldName, DataId, IsographEnvironment } from './IsographEnvironment';
+import { IsographEntrypoint, IsographEntrypointLoader, RefetchQueryNormalizationArtifact, RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
+import { Arguments } from './util';
+export type TopLevelReaderArtifact<TReadFromStore extends Object, TClientFieldValue, TComponentProps extends Record<string, never>> = EagerReaderArtifact<TReadFromStore, TClientFieldValue> | ComponentReaderArtifact<TReadFromStore, TComponentProps>;
+export type EagerReaderArtifact<TReadFromStore extends Object, TClientFieldValue> = {
+    readonly kind: 'EagerReaderArtifact';
+    readonly readerAst: ReaderAst<TReadFromStore>;
+    readonly resolver: (data: TReadFromStore) => TClientFieldValue;
+};
+export type ComponentReaderArtifact<TReadFromStore extends Object, TComponentProps extends Record<string, unknown> = Record<string, never>> = {
+    readonly kind: 'ComponentReaderArtifact';
+    readonly componentName: ComponentOrFieldName;
+    readonly readerAst: ReaderAst<TReadFromStore>;
+    readonly resolver: (data: TReadFromStore, runtimeProps: TComponentProps) => React.ReactNode;
+};
+export type RefetchReaderArtifact = {
+    readonly kind: 'RefetchReaderArtifact';
+    readonly readerAst: ReaderAst<unknown>;
+    readonly resolver: (environment: IsographEnvironment, artifact: RefetchQueryNormalizationArtifact, variables: any, filteredVariables: any, rootId: DataId, readerArtifact: TopLevelReaderArtifact<any, any, any> | null, nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[]) => () => void;
+};
+export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderNonLoadableResolverField | ReaderImperativelyLoadedField | ReaderLoadableField;
+export type ReaderAst<TReadFromStore> = ReadonlyArray<ReaderAstNode>;
+export type ReaderScalarField = {
+    readonly kind: 'Scalar';
+    readonly fieldName: string;
+    readonly alias: string | null;
+    readonly arguments: Arguments | null;
+};
+export type ReaderLinkedField = {
+    readonly kind: 'Linked';
+    readonly fieldName: string;
+    readonly alias: string | null;
+    readonly selections: ReaderAst<unknown>;
+    readonly arguments: Arguments | null;
+};
+export type ReaderNonLoadableResolverField = {
+    readonly kind: 'Resolver';
+    readonly alias: string;
+    readonly readerArtifact: TopLevelReaderArtifact<any, any, any>;
+    readonly arguments: Arguments | null;
+    readonly usedRefetchQueries: number[];
+};
+export type ReaderImperativelyLoadedField = {
+    readonly kind: 'ImperativelyLoadedField';
+    readonly alias: string;
+    readonly refetchReaderArtifact: RefetchReaderArtifact;
+    readonly refetchQuery: number;
+    readonly name: string;
+};
+export type ReaderLoadableField = {
+    readonly kind: 'LoadablySelectedField';
+    readonly alias: string;
+    readonly name: string;
+    readonly queryArguments: Arguments | null;
+    readonly refetchReaderAst: ReaderAst<any>;
+    readonly entrypoint: IsographEntrypoint<any, any> | IsographEntrypointLoader<any, any>;
+};
+type StableId = string;
+export type LoadableField<TArgs, TResult> = (args: TArgs) => [StableId, Factory<FragmentReference<any, TResult>>];
+export {};

package/dist/core/reader.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/util.d.ts

@@ -0,0 +1,17 @@
+export type ExtractSecondParam<T extends (arg1: any, arg2: any) => any> = T extends (arg1: any, arg2: infer P) => any ? P : never;
+export type Arguments = Argument[];
+export type Argument = [ArgumentName, ArgumentValue];
+export type ArgumentName = string;
+export type ArgumentValue = {
+    readonly kind: 'Variable';
+    readonly name: string;
+} | {
+    readonly kind: 'Literal';
+    readonly value: any;
+} | {
+    readonly kind: 'String';
+    readonly value: string;
+} | {
+    readonly kind: 'Enum';
+    readonly value: string;
+};

package/dist/core/util.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });