@isograph/react 0.0.0-main-4ef7c123

package/dist/PromiseWrapper.d.ts

@@ -0,0 +1,13 @@
+declare const NOT_SET: Symbol;
+type NotSet = typeof NOT_SET;
+/**
+ * Invariant:
+ * Before the promise is resolved, value becomes non-null.
+ */
+export type PromiseWrapper<T> = {
+    promise: Promise<T>;
+    value: Exclude<T, NotSet> | NotSet;
+};
+export declare function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T>;
+export declare function useReadPromise<T>(p: PromiseWrapper<T>): T;
+export {};

package/dist/PromiseWrapper.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReadPromise = exports.wrapPromise = void 0;
+const NOT_SET = Symbol("NOT_SET");
+function wrapPromise(promise) {
+    // TODO confirm suspense works if the promise is already resolved.
+    const wrapper = { promise, value: NOT_SET };
+    promise.then((v) => {
+        // T is assignable to Exclude<T, Symbol> | Symbol
+        wrapper.value = v;
+    });
+    return wrapper;
+}
+exports.wrapPromise = wrapPromise;
+function useReadPromise(p) {
+    if (p.value !== NOT_SET) {
+        // Safety: p.value is either NOT_SET or an actual value.
+        return p.value;
+    }
+    throw p.promise;
+}
+exports.useReadPromise = useReadPromise;

package/dist/cache.d.ts

@@ -0,0 +1,30 @@
+import { ItemCleanupPair, ParentCache } from "@isograph/react-disposable-state";
+import { PromiseWrapper } from "./PromiseWrapper";
+import { IsographFetchableResolver, NormalizationLinkedField, NormalizationScalarField, ReaderLinkedField, ReaderScalarField } from "./index";
+type IsoResolver = IsographFetchableResolver<any, any, any>;
+export declare function getOrCreateCacheForArtifact<T>(artifact: IsoResolver, variables: object): ParentCache<PromiseWrapper<T>>;
+declare let network: ((queryText: string, variables: object) => Promise<any>) | null;
+export declare function setNetwork(newNetwork: typeof network): void;
+export declare function makeNetworkRequest<T>(artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
+export type Link = {
+    __link: DataId;
+};
+export type DataTypeValue = undefined | number | boolean | string | null | Link | DataTypeValue[];
+export type StoreRecord = {
+    [index: DataId | string]: DataTypeValue;
+    id?: DataId;
+};
+export type DataId = string;
+export declare const ROOT_ID: DataId & "__ROOT";
+export declare const store: {
+    [index: DataId]: StoreRecord | null;
+    __ROOT: StoreRecord;
+};
+export declare function subscribe(callback: () => void): () => void;
+export declare function onNextChange(): Promise<void>;
+export declare function getParentRecordKey(astNode: NormalizationLinkedField | NormalizationScalarField | ReaderLinkedField | ReaderScalarField, variables: {
+    [index: string]: string;
+}): string;
+export declare const FIRST_SPLIT_KEY = "____";
+export declare const SECOND_SPLIT_KEY = "___";
+export {};

package/dist/cache.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECOND_SPLIT_KEY = exports.FIRST_SPLIT_KEY = exports.getParentRecordKey = exports.onNextChange = exports.subscribe = exports.store = exports.ROOT_ID = exports.makeNetworkRequest = exports.setNetwork = exports.getOrCreateCacheForArtifact = void 0;
+const react_disposable_state_1 = require("@isograph/react-disposable-state");
+const PromiseWrapper_1 = require("./PromiseWrapper");
+const cache = {};
+function getOrCreateCache(index, factory) {
+    console.log("getting cache for", {
+        index,
+        cache: Object.keys(cache),
+        found: !!cache[index],
+    });
+    if (cache[index] == null) {
+        cache[index] = new react_disposable_state_1.ParentCache(factory);
+    }
+    return cache[index];
+}
+/**
+ * Creates a copy of the provided value, ensuring any nested objects have their
+ * keys sorted such that equivalent values would have identical JSON.stringify
+ * results.
+ */
+function stableCopy(value) {
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        // @ts-ignore
+        return value.map(stableCopy);
+    }
+    const keys = Object.keys(value).sort();
+    const stable = {};
+    for (let i = 0; i < keys.length; i++) {
+        // @ts-ignore
+        stable[keys[i]] = stableCopy(value[keys[i]]);
+    }
+    return stable;
+}
+function getOrCreateCacheForArtifact(artifact, variables) {
+    const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
+    const factory = () => makeNetworkRequest(artifact, variables);
+    return getOrCreateCache(cacheKey, factory);
+}
+exports.getOrCreateCacheForArtifact = getOrCreateCacheForArtifact;
+let network;
+// This is a hack until we store this in context somehow
+function setNetwork(newNetwork) {
+    network = newNetwork;
+}
+exports.setNetwork = setNetwork;
+function makeNetworkRequest(artifact, variables) {
+    console.log("make network request", artifact, variables);
+    if (network == null) {
+        throw new Error("Network must be set before makeNetworkRequest is called");
+    }
+    const promise = network(artifact.queryText, variables).then((networkResponse) => {
+        console.log("network response", artifact);
+        normalizeData(artifact.normalizationAst, networkResponse.data, variables, artifact.nestedRefetchQueries);
+        return networkResponse.data;
+    });
+    const wrapper = (0, PromiseWrapper_1.wrapPromise)(promise);
+    const response = [
+        wrapper,
+        () => {
+            // delete from cache
+        },
+    ];
+    return response;
+}
+exports.makeNetworkRequest = makeNetworkRequest;
+exports.ROOT_ID = "__ROOT";
+exports.store = {
+    __ROOT: {},
+};
+function normalizeData(normalizationAst, networkResponse, variables, nestedRefetchQueries) {
+    console.log("about to normalize", normalizationAst, networkResponse, variables);
+    normalizeDataIntoRecord(normalizationAst, networkResponse, exports.store.__ROOT, exports.ROOT_ID, variables, nestedRefetchQueries);
+    console.log("after normalization", { store: exports.store });
+    callSubscriptions();
+}
+function subscribe(callback) {
+    subscriptions.add(callback);
+    return () => subscriptions.delete(callback);
+}
+exports.subscribe = subscribe;
+function onNextChange() {
+    return new Promise((resolve) => {
+        const unsubscribe = subscribe(() => {
+            unsubscribe();
+            resolve();
+        });
+    });
+}
+exports.onNextChange = onNextChange;
+const subscriptions = new Set();
+function callSubscriptions() {
+    subscriptions.forEach((callback) => callback());
+}
+/**
+ * Mutate targetParentRecord according to the normalizationAst and networkResponseParentRecord.
+ */
+function normalizeDataIntoRecord(normalizationAst, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+    for (const normalizationNode of normalizationAst) {
+        switch (normalizationNode.kind) {
+            case "Scalar": {
+                normalizeScalarField(normalizationNode, networkResponseParentRecord, targetParentRecord, variables);
+                break;
+            }
+            case "Linked": {
+                normalizeLinkedField(normalizationNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries);
+                break;
+            }
+        }
+    }
+}
+function normalizeScalarField(astNode, networkResponseParentRecord, targetStoreRecord, variables) {
+    const networkResponseKey = getNetworkResponseKey(astNode);
+    const networkResponseData = networkResponseParentRecord[networkResponseKey];
+    const parentRecordKey = getParentRecordKey(astNode, variables);
+    if (networkResponseData == null ||
+        isScalarOrEmptyArray(networkResponseData)) {
+        targetStoreRecord[parentRecordKey] = networkResponseData;
+    }
+    else {
+        throw new Error("Unexpected object array when normalizing scalar");
+    }
+}
+/**
+ * Mutate targetParentRecord with a given linked field ast node.
+ */
+function normalizeLinkedField(astNode, networkResponseParentRecord, targetParentRecord, targetParentRecordId, variables, nestedRefetchQueries) {
+    const networkResponseKey = getNetworkResponseKey(astNode);
+    const networkResponseData = networkResponseParentRecord[networkResponseKey];
+    const parentRecordKey = getParentRecordKey(astNode, variables);
+    if (networkResponseData == null) {
+        targetParentRecord[parentRecordKey] = null;
+        return;
+    }
+    if (isScalarButNotEmptyArray(networkResponseData)) {
+        throw new Error("Unexpected scalar network response when normalizing a linked field");
+    }
+    if (Array.isArray(networkResponseData)) {
+        // TODO check astNode.plural or the like
+        const dataIds = [];
+        for (let i = 0; i < networkResponseData.length; i++) {
+            const networkResponseObject = networkResponseData[i];
+            const newStoreRecordId = normalizeNetworkResponseObject(astNode, networkResponseObject, targetParentRecordId, variables, i, nestedRefetchQueries);
+            dataIds.push({ __link: newStoreRecordId });
+        }
+        targetParentRecord[parentRecordKey] = dataIds;
+    }
+    else {
+        const newStoreRecordId = normalizeNetworkResponseObject(astNode, networkResponseData, targetParentRecordId, variables, null, nestedRefetchQueries);
+        targetParentRecord[parentRecordKey] = {
+            __link: newStoreRecordId,
+        };
+    }
+}
+function normalizeNetworkResponseObject(astNode, networkResponseData, targetParentRecordId, variables, index, nestedRefetchQueries) {
+    var _a;
+    const newStoreRecordId = getDataIdOfNetworkResponse(targetParentRecordId, networkResponseData, astNode, variables, index);
+    const newStoreRecord = (_a = exports.store[newStoreRecordId]) !== null && _a !== void 0 ? _a : {};
+    exports.store[newStoreRecordId] = newStoreRecord;
+    normalizeDataIntoRecord(astNode.selections, networkResponseData, newStoreRecord, newStoreRecordId, variables, nestedRefetchQueries);
+    return newStoreRecordId;
+}
+function isScalarOrEmptyArray(data) {
+    // N.B. empty arrays count as empty arrays of scalar fields.
+    if (Array.isArray(data)) {
+        // This is maybe fixed in a new version of Typescript??
+        return data.every((x) => isScalarOrEmptyArray(x));
+    }
+    const isScalarValue = typeof data === "string" ||
+        typeof data === "number" ||
+        typeof data === "boolean";
+    return isScalarValue;
+}
+function isScalarButNotEmptyArray(data) {
+    // N.B. empty arrays count as empty arrays of linked fields.
+    if (Array.isArray(data)) {
+        if (data.length === 0) {
+            return false;
+        }
+        // This is maybe fixed in a new version of Typescript??
+        return data.every((x) => isScalarOrEmptyArray(x));
+    }
+    const isScalarValue = typeof data === "string" ||
+        typeof data === "number" ||
+        typeof data === "boolean";
+    return isScalarValue;
+}
+function getParentRecordKey(astNode, variables) {
+    let parentRecordKey = astNode.fieldName;
+    const fieldParameters = astNode.arguments;
+    if (fieldParameters != null) {
+        for (const fieldParameter of fieldParameters) {
+            const { argumentName, variableName } = fieldParameter;
+            const valueToUse = variables[variableName];
+            parentRecordKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${valueToUse}`;
+        }
+    }
+    return parentRecordKey;
+}
+exports.getParentRecordKey = getParentRecordKey;
+function getNetworkResponseKey(astNode) {
+    let networkResponseKey = astNode.fieldName;
+    const fieldParameters = astNode.arguments;
+    if (fieldParameters != null) {
+        for (const fieldParameter of fieldParameters) {
+            const { argumentName, variableName } = fieldParameter;
+            networkResponseKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${variableName}`;
+        }
+    }
+    return networkResponseKey;
+}
+// an alias might be pullRequests____first___first____after___cursor
+exports.FIRST_SPLIT_KEY = "____";
+exports.SECOND_SPLIT_KEY = "___";
+// Returns a key to look up an item in the store
+function getDataIdOfNetworkResponse(parentRecordId, dataToNormalize, astNode, variables, index) {
+    // Check whether the dataToNormalize has an id field. If so, that is the key.
+    // If not, we construct an id from the parentRecordId and the field parameters.
+    const dataId = dataToNormalize.id;
+    if (dataId != null) {
+        return dataId;
+    }
+    let storeKey = `${parentRecordId}.${astNode.fieldName}`;
+    if (index != null) {
+        storeKey += `.${index}`;
+    }
+    const fieldParameters = astNode.arguments;
+    if (fieldParameters == null) {
+        return storeKey;
+    }
+    for (const fieldParameter of fieldParameters) {
+        const { argumentName, variableName } = fieldParameter;
+        const valueToUse = variables[variableName];
+        storeKey += `${exports.FIRST_SPLIT_KEY}${argumentName}${exports.SECOND_SPLIT_KEY}${valueToUse}`;
+    }
+    return storeKey;
+}

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+import { DataId, StoreRecord, Link } from "./cache";
+export { setNetwork, makeNetworkRequest, subscribe, DataId, Link, StoreRecord, } from "./cache";
+export type IsographFetchableResolver<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
+    kind: "FetchableResolver";
+    queryText: string;
+    normalizationAst: NormalizationAst;
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverProps, TResolverResult>;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+export type ReaderArtifact<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
+    kind: "ReaderArtifact";
+    readerAst: ReaderAst<TReadFromStore>;
+    resolver: (data: TResolverProps) => TResolverResult;
+    variant: ReaderResolverVariant;
+};
+export type ReaderAstNode = ReaderScalarField | ReaderLinkedField | ReaderResolverField | ReaderRefetchField | ReaderMutationField;
+export type ReaderAst<TReadFromStore> = ReaderAstNode[];
+export type ReaderScalarField = {
+    kind: "Scalar";
+    fieldName: string;
+    alias: string | null;
+    arguments: Arguments | null;
+};
+export type ReaderLinkedField = {
+    kind: "Linked";
+    fieldName: string;
+    alias: string | null;
+    selections: ReaderAst<unknown>;
+    arguments: Arguments | null;
+};
+export type ReaderResolverVariant = {
+    kind: "Eager";
+} | {
+    kind: "Component";
+    componentName: string;
+};
+export type ReaderResolverField = {
+    kind: "Resolver";
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any, any>;
+    arguments: Arguments | null;
+    usedRefetchQueries: number[];
+};
+export type ReaderRefetchField = {
+    kind: "RefetchField";
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any, any>;
+    refetchQuery: number;
+};
+export type ReaderMutationField = {
+    kind: "MutationField";
+    alias: string;
+    readerArtifact: ReaderArtifact<any, any, any>;
+    refetchQuery: number;
+    allowedVariables: string[];
+};
+export type NormalizationAstNode = NormalizationScalarField | NormalizationLinkedField;
+export type NormalizationAst = NormalizationAstNode[];
+export type NormalizationScalarField = {
+    kind: "Scalar";
+    fieldName: string;
+    arguments: Arguments | null;
+};
+export type NormalizationLinkedField = {
+    kind: "Linked";
+    fieldName: string;
+    arguments: Arguments | null;
+    selections: NormalizationAst;
+};
+export type RefetchQueryArtifact = {
+    kind: "RefetchQuery";
+    queryText: string;
+    normalizationAst: NormalizationAst;
+};
+export type RefetchQueryArtifactWrapper = {
+    artifact: RefetchQueryArtifact;
+    allowedVariables: string[];
+};
+export type Arguments = Argument[];
+export type Argument = {
+    argumentName: string;
+    variableName: string;
+};
+export type FragmentReference<TReadFromStore extends Object, TResolverProps, TResolverResult> = {
+    kind: "FragmentReference";
+    readerArtifact: ReaderArtifact<TReadFromStore, TResolverProps, TResolverResult>;
+    root: DataId;
+    variables: {
+        [index: string]: string;
+    } | null;
+    nestedRefetchQueries: RefetchQueryArtifactWrapper[];
+};
+export declare function isoFetch<T extends IsographFetchableResolver<any, any, any>>(_text: TemplateStringsArray): T;
+export declare function iso<TResolverParameter, TResolverReturn = TResolverParameter>(_queryText: TemplateStringsArray): (x: ((param: TResolverParameter) => TResolverReturn) | void) => (param: TResolverParameter) => TResolverReturn;
+export declare function useLazyReference<TReadFromStore extends Object, TResolverProps, TResolverResult>(fetchableResolverArtifact: IsographFetchableResolver<TReadFromStore, TResolverProps, TResolverResult>, variables: object): {
+    queryReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>;
+};
+export declare function read<TReadFromStore extends Object, TResolverProps, TResolverResult>(fragmentReference: FragmentReference<TReadFromStore, TResolverProps, TResolverResult>): TResolverResult;
+export declare function readButDoNotEvaluate<TReadFromStore extends Object>(reference: FragmentReference<TReadFromStore, unknown, unknown>): TReadFromStore;
+export declare function defaultMissingFieldHandler(storeRecord: StoreRecord, root: DataId, fieldName: string, arguments_: {
+    [index: string]: any;
+} | null, variables: {
+    [index: string]: any;
+} | null): Link | undefined;
+export declare function setMissingFieldHandler(handler: typeof defaultMissingFieldHandler): void;
+export declare function getRefReaderForName(name: string): any;
+export type IsographComponentProps<TDataType, TOtherProps = Object> = {
+    data: TDataType;
+} & TOtherProps;