@isograph/react 0.0.0-main-4ef7c123

package/dist/index.js

@@ -0,0 +1,333 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefReaderForName = exports.setMissingFieldHandler = exports.defaultMissingFieldHandler = exports.readButDoNotEvaluate = exports.read = exports.useLazyReference = exports.iso = exports.isoFetch = exports.subscribe = exports.makeNetworkRequest = exports.setNetwork = void 0;
+const cache_1 = require("./cache");
+const react_disposable_state_1 = require("@isograph/react-disposable-state");
+const react_1 = __importDefault(require("react"));
+var cache_2 = require("./cache");
+Object.defineProperty(exports, "setNetwork", { enumerable: true, get: function () { return cache_2.setNetwork; } });
+Object.defineProperty(exports, "makeNetworkRequest", { enumerable: true, get: function () { return cache_2.makeNetworkRequest; } });
+Object.defineProperty(exports, "subscribe", { enumerable: true, get: function () { return cache_2.subscribe; } });
+function isoFetch(_text) {
+    return void 0;
+}
+exports.isoFetch = isoFetch;
+function iso(_queryText) {
+    // The name `identity` here is a bit of a double entendre.
+    // First, it is the identity function, constrained to operate
+    // on a very specific type. Thus, the value of b Declare`...`(
+    // someFunction) is someFunction. But furthermore, if one
+    // write b Declare`...` and passes no function, the resolver itself
+    // is the identity function. At that point, the types
+    // TResolverParameter and TResolverReturn must be identical.
+    return function identity(x) {
+        return x;
+    };
+}
+exports.iso = iso;
+function useLazyReference(fetchableResolverArtifact, variables) {
+    // Typechecking fails here... TODO investigate
+    const cache = (0, cache_1.getOrCreateCacheForArtifact)(fetchableResolverArtifact, variables);
+    // TODO add comment explaining why we never use this value
+    // @ts-ignore
+    const data = 
+    // @ts-ignore
+    (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
+    return {
+        queryReference: {
+            kind: "FragmentReference",
+            readerArtifact: fetchableResolverArtifact.readerArtifact,
+            root: cache_1.ROOT_ID,
+            variables,
+            nestedRefetchQueries: fetchableResolverArtifact.nestedRefetchQueries,
+        },
+    };
+}
+exports.useLazyReference = useLazyReference;
+function read(fragmentReference) {
+    var _a;
+    const variant = fragmentReference.readerArtifact.variant;
+    if (variant.kind === "Eager") {
+        const data = readData(fragmentReference.readerArtifact.readerAst, fragmentReference.root, (_a = fragmentReference.variables) !== null && _a !== void 0 ? _a : {}, fragmentReference.nestedRefetchQueries);
+        if (data.kind === "MissingData") {
+            throw (0, cache_1.onNextChange)();
+        }
+        else {
+            return fragmentReference.readerArtifact.resolver(data.data);
+        }
+    }
+    else if (variant.kind === "Component") {
+        return (additionalRuntimeProps) => {
+            // TODO also incorporate the typename
+            const RefReaderForName = getRefReaderForName(variant.componentName);
+            // TODO do not create a new reference on every render?
+            return (react_1.default.createElement(RefReaderForName, { reference: {
+                    kind: "FragmentReference",
+                    readerArtifact: fragmentReference.readerArtifact,
+                    root: fragmentReference.root,
+                    variables: fragmentReference.variables,
+                    nestedRefetchQueries: fragmentReference.nestedRefetchQueries,
+                }, additionalRuntimeProps: additionalRuntimeProps }));
+        };
+    }
+    // Why can't Typescript realize that this is unreachable??
+    throw new Error("This is unreachable");
+}
+exports.read = read;
+function readButDoNotEvaluate(reference) {
+    var _a;
+    const response = readData(reference.readerArtifact.readerAst, reference.root, (_a = reference.variables) !== null && _a !== void 0 ? _a : {}, reference.nestedRefetchQueries);
+    console.log("done reading but not evaluating", { response });
+    if (response.kind === "MissingData") {
+        throw (0, cache_1.onNextChange)();
+    }
+    else {
+        return response.data;
+    }
+}
+exports.readButDoNotEvaluate = readButDoNotEvaluate;
+function readData(ast, root, variables, nestedRefetchQueries) {
+    var _a, _b, _c, _d;
+    let storeRecord = cache_1.store[root];
+    if (storeRecord === undefined) {
+        return { kind: "MissingData", reason: "No record for root " + root };
+    }
+    if (storeRecord === null) {
+        return { kind: "Success", data: null };
+    }
+    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 = 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(field.selections, link.__link, variables, nestedRefetchQueries);
+                        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 = assertLink(value);
+                if (link === undefined) {
+                    // TODO make this configurable, and also generated and derived from the schema
+                    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[(_c = field.alias) !== null && _c !== void 0 ? _c : field.fieldName] = null;
+                    break;
+                }
+                const targetId = link.__link;
+                const data = readData(field.selections, targetId, variables, nestedRefetchQueries);
+                if (data.kind === "MissingData") {
+                    return {
+                        kind: "MissingData",
+                        reason: "Missing data for " + storeRecordName + " on root " + root,
+                        nestedReason: data,
+                    };
+                }
+                target[(_d = field.alias) !== null && _d !== void 0 ? _d : field.fieldName] = data.data;
+                break;
+            }
+            case "RefetchField": {
+                const data = readData(field.readerArtifact.readerAst, root, variables, 
+                // Refetch fields just read the id, and don't need refetch query artifacts
+                []);
+                console.log("refetch field data", data, field);
+                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;
+                    target[field.alias] = field.readerArtifact.resolver(refetchQueryArtifact, Object.assign(Object.assign({}, data.data), filterVariables(variables, allowedVariables)));
+                }
+                break;
+            }
+            case "MutationField": {
+                const data = readData(field.readerArtifact.readerAst, root, variables, 
+                // Refetch fields just read the id, and don't need refetch query artifacts
+                []);
+                console.log("refetch field data", data, field);
+                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 MutationField");
+                    }
+                    const refetchQuery = nestedRefetchQueries[refetchQueryIndex];
+                    const refetchQueryArtifact = refetchQuery.artifact;
+                    const allowedVariables = refetchQuery.allowedVariables;
+                    target[field.alias] = field.readerArtifact.resolver(refetchQueryArtifact, data.data, filterVariables(variables, allowedVariables));
+                }
+                break;
+            }
+            case "Resolver": {
+                const usedRefetchQueries = field.usedRefetchQueries;
+                const resolverRefetchQueries = usedRefetchQueries.map((index) => nestedRefetchQueries[index]);
+                const variant = field.readerArtifact.variant;
+                if (variant.kind === "Eager") {
+                    const data = readData(field.readerArtifact.readerAst, root, variables, resolverRefetchQueries);
+                    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);
+                    }
+                }
+                else if (variant.kind === "Component") {
+                    target[field.alias] = (additionalRuntimeProps) => {
+                        // TODO also incorporate the typename
+                        const RefReaderForName = getRefReaderForName(variant.componentName);
+                        // TODO do not create a new reference on every render?
+                        return (react_1.default.createElement(RefReaderForName, { reference: {
+                                kind: "FragmentReference",
+                                readerArtifact: field.readerArtifact,
+                                root,
+                                variables,
+                                nestedRefetchQueries: resolverRefetchQueries,
+                            }, additionalRuntimeProps: additionalRuntimeProps }));
+                    };
+                }
+                break;
+            }
+        }
+    }
+    return { kind: "Success", data: target };
+}
+let customMissingFieldHandler = null;
+function missingFieldHandler(storeRecord, root, fieldName, arguments_, variables) {
+    if (customMissingFieldHandler != null) {
+        return customMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables);
+    }
+    else {
+        return defaultMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables);
+    }
+}
+function defaultMissingFieldHandler(storeRecord, root, fieldName, arguments_, variables) {
+    if (fieldName === "node" || fieldName === "user") {
+        const variable = arguments_ === null || arguments_ === void 0 ? void 0 : arguments_["id"];
+        const value = variables === null || variables === void 0 ? void 0 : variables[variable];
+        // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
+        if (value != null) {
+            return { __link: value };
+        }
+    }
+}
+exports.defaultMissingFieldHandler = defaultMissingFieldHandler;
+function setMissingFieldHandler(handler) {
+    customMissingFieldHandler = handler;
+}
+exports.setMissingFieldHandler = setMissingFieldHandler;
+function assertLink(link) {
+    if (Array.isArray(link)) {
+        throw new Error("Unexpected array");
+    }
+    if (typeof link === "object") {
+        return link;
+    }
+    if (link === undefined) {
+        return undefined;
+    }
+    throw new Error("Invalid link");
+}
+const refReaders = {};
+function getRefReaderForName(name) {
+    if (refReaders[name] == null) {
+        function Component({ reference, additionalRuntimeProps, }) {
+            const data = readButDoNotEvaluate(reference);
+            return reference.readerArtifact.resolver(Object.assign({ data }, additionalRuntimeProps));
+        }
+        Component.displayName = `${name} @component`;
+        refReaders[name] = Component;
+    }
+    return refReaders[name];
+}
+exports.getRefReaderForName = getRefReaderForName;
+function filterVariables(variables, allowedVariables) {
+    const result = {};
+    for (const key of allowedVariables) {
+        result[key] = variables[key];
+    }
+    return result;
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@isograph/react",
+  "version": "0.0.0-main-4ef7c123",
+  "description": "Use Isograph with React",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Isograph Labs",
+  "license": "MIT",
+  "scripts": {
+    "compile": "rm -rf dist/* && (tsc -p tsconfig.pkg.json || exit 0)",
+    "compile-watch": "tsc -p tsconfig.pkg.json --watch",
+    "test": "echo no tests yet",
+    "test-watch": "vitest watch",
+    "coverage": "vitest run --coverage",
+    "prepack": "yarn run test && yarn run compile"
+  },
+  "dependencies": {
+    "@isograph/disposable-types": "0.0.0-main-4ef7c123",
+    "@isograph/react-disposable-state": "0.0.0-main-4ef7c123",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.31",
+    "react-test-renderer": "^18.2.0",
+    "vitest": "^0.29.8",
+    "typescript": "^5.0.3"
+  }
+}

package/src/PromiseWrapper.ts

@@ -0,0 +1,29 @@
+const NOT_SET: Symbol = Symbol("NOT_SET");
+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 function wrapPromise<T>(promise: Promise<T>): PromiseWrapper<T> {
+  // TODO confirm suspense works if the promise is already resolved.
+  const wrapper: PromiseWrapper<T> = { promise, value: NOT_SET };
+  promise.then((v) => {
+    // T is assignable to Exclude<T, Symbol> | Symbol
+    wrapper.value = v as any;
+  });
+  return wrapper;
+}
+
+export function useReadPromise<T>(p: PromiseWrapper<T>): T {
+  if (p.value !== NOT_SET) {
+    // Safety: p.value is either NOT_SET or an actual value.
+    return p.value as any;
+  }
+  throw p.promise;
+}