@isograph/react 0.0.0-main-adb0955b → 0.0.0-main-ba9f1dc0

package/dist/core/check.d.ts

@@ -0,0 +1,11 @@
+import { NormalizationAst } from './entrypoint';
+import { Variables } from './FragmentReference';
+import { IsographEnvironment, Link } from './IsographEnvironment';
+type CheckResult = {
+    kind: 'EnoughData';
+} | {
+    kind: 'MissingData';
+    record: Link;
+};
+export declare function check(environment: IsographEnvironment, normalizationAst: NormalizationAst, variables: Variables): CheckResult;
+export {};

package/dist/core/check.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.check = check;
+const cache_1 = require("./cache");
+const IsographEnvironment_1 = require("./IsographEnvironment");
+function check(environment, normalizationAst, variables) {
+    return checkFromRecord(environment, normalizationAst, variables, environment.store[IsographEnvironment_1.ROOT_ID], IsographEnvironment_1.ROOT_ID);
+}
+function checkFromRecord(environment, normalizationAst, variables, record, backupId) {
+    var _a, _b, _c;
+    normalizationAstLoop: for (const normalizationAstNode of normalizationAst) {
+        switch (normalizationAstNode.kind) {
+            case 'Scalar': {
+                const parentRecordKey = (0, cache_1.getParentRecordKey)(normalizationAstNode, variables);
+                const scalarValue = record[parentRecordKey];
+                // null means the value is known to be missing, so it must
+                // be exactly undefined
+                if (scalarValue === undefined) {
+                    return {
+                        kind: 'MissingData',
+                        record: {
+                            __link: (_a = record.id) !== null && _a !== void 0 ? _a : backupId,
+                        },
+                    };
+                }
+                continue normalizationAstLoop;
+            }
+            case 'Linked': {
+                const parentRecordKey = (0, cache_1.getParentRecordKey)(normalizationAstNode, variables);
+                const linkedValue = record[parentRecordKey];
+                if (linkedValue === undefined) {
+                    return {
+                        kind: 'MissingData',
+                        record: {
+                            __link: (_b = record.id) !== null && _b !== void 0 ? _b : backupId,
+                        },
+                    };
+                }
+                else if (linkedValue === null) {
+                    continue;
+                }
+                else if (Array.isArray(linkedValue)) {
+                    arrayItemsLoop: for (const item of linkedValue) {
+                        const link = (0, IsographEnvironment_1.getLink)(item);
+                        if (link === null) {
+                            throw new Error('Unexpected non-link in the Isograph store. ' +
+                                'This is indicative of a bug in Isograph.');
+                        }
+                        const linkedRecord = environment.store[link.__link];
+                        if (linkedRecord === undefined) {
+                            return {
+                                kind: 'MissingData',
+                                record: link,
+                            };
+                        }
+                        else if (linkedRecord === null) {
+                            continue arrayItemsLoop;
+                        }
+                        else {
+                            // TODO in __DEV__ assert linkedRecord is an object
+                            const result = checkFromRecord(environment, normalizationAstNode.selections, variables, linkedRecord, 
+                            // TODO this seems likely to be wrong
+                            backupId + '.' + parentRecordKey);
+                            if (result.kind === 'MissingData') {
+                                return result;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const link = (0, IsographEnvironment_1.getLink)(linkedValue);
+                    if (link === null) {
+                        throw new Error('Unexpected non-link in the Isograph store. ' +
+                            'This is indicative of a bug in Isograph.');
+                    }
+                    const linkedRecord = environment.store[link.__link];
+                    if (linkedRecord === undefined) {
+                        return {
+                            kind: 'MissingData',
+                            record: link,
+                        };
+                    }
+                    else if (linkedRecord === null) {
+                        continue normalizationAstLoop;
+                    }
+                    else {
+                        // TODO in __DEV__ assert linkedRecord is an object
+                        const result = checkFromRecord(environment, normalizationAstNode.selections, variables, linkedRecord, 
+                        // TODO this seems likely to be wrong
+                        backupId + '.' + parentRecordKey);
+                        if (result.kind === 'MissingData') {
+                            return result;
+                        }
+                    }
+                }
+                continue normalizationAstLoop;
+            }
+            case 'InlineFragment': {
+                const existingRecordTypename = record['__typename'];
+                if (existingRecordTypename == null ||
+                    existingRecordTypename !== normalizationAstNode.type) {
+                    return {
+                        kind: 'MissingData',
+                        record: {
+                            __link: (_c = record.id) !== null && _c !== void 0 ? _c : backupId,
+                        },
+                    };
+                }
+                const result = checkFromRecord(environment, normalizationAstNode.selections, variables, record, backupId);
+                if (result.kind === 'MissingData') {
+                    return result;
+                }
+                continue normalizationAstLoop;
+            }
+            default: {
+                let _ = normalizationAstNode;
+                _;
+                throw new Error('Unexpected case. This is indicative of a bug in Isograph.');
+            }
+        }
+    }
+    return {
+        kind: 'EnoughData',
+    };
+}

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { readButDoNotEvaluate } from './core/read';
 export { type ExtractSecondParam, type CombineWithIntrinsicAttributes, type Argument, type ArgumentName, type ArgumentValue, type Arguments, } from './core/util';
 export { type FragmentReference, type Variables, type ExtractParameters, type ExtractData, stableIdForFragmentReference, } from './core/FragmentReference';
 export { type LogMessage, type LogFunction, logMessage, registerLogger, } from './core/logging';
+export { check } from './core/check';
 export { IsographEnvironmentProvider, useIsographEnvironment, type IsographEnvironmentProviderProps, } from './react/IsographEnvironmentProvider';
 export { useImperativeReference } from './react/useImperativeReference';
 export { FragmentReader } from './react/FragmentReader';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useImperativeLoadableField = exports.useConnectionSpecPagination = exports.useSkipLimitPagination = exports.useImperativeExposedMutationField = exports.useClientSideDefer = exports.RenderAfterCommit__DO_NOT_USE = exports.useRerenderOnChange = exports.useLazyReference = exports.useSubscribeToMultiple = exports.useReadAndSubscribe = exports.useResult = exports.FragmentReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.registerLogger = exports.logMessage = exports.stableIdForFragmentReference = exports.readButDoNotEvaluate = exports.assertIsEntrypoint = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.makeNetworkRequest = exports.normalizeData = exports.subscribe = exports.wrapPromise = exports.wrapResolvedValue = exports.getPromiseState = exports.readPromise = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
+exports.useImperativeLoadableField = exports.useConnectionSpecPagination = exports.useSkipLimitPagination = exports.useImperativeExposedMutationField = exports.useClientSideDefer = exports.RenderAfterCommit__DO_NOT_USE = exports.useRerenderOnChange = exports.useLazyReference = exports.useSubscribeToMultiple = exports.useReadAndSubscribe = exports.useResult = exports.FragmentReader = exports.useImperativeReference = exports.useIsographEnvironment = exports.IsographEnvironmentProvider = exports.check = exports.registerLogger = exports.logMessage = exports.stableIdForFragmentReference = exports.readButDoNotEvaluate = exports.assertIsEntrypoint = exports.defaultMissingFieldHandler = exports.createIsographStore = exports.createIsographEnvironment = exports.ROOT_ID = exports.makeNetworkRequest = exports.normalizeData = exports.subscribe = exports.wrapPromise = exports.wrapResolvedValue = exports.getPromiseState = exports.readPromise = exports.garbageCollectEnvironment = exports.unretainQuery = exports.retainQuery = void 0;
 var garbageCollection_1 = require("./core/garbageCollection");
 Object.defineProperty(exports, "retainQuery", { enumerable: true, get: function () { return garbageCollection_1.retainQuery; } });
 Object.defineProperty(exports, "unretainQuery", { enumerable: true, get: function () { return garbageCollection_1.unretainQuery; } });
@@ -29,6 +29,8 @@ Object.defineProperty(exports, "stableIdForFragmentReference", { enumerable: tru
 var logging_1 = require("./core/logging");
 Object.defineProperty(exports, "logMessage", { enumerable: true, get: function () { return logging_1.logMessage; } });
 Object.defineProperty(exports, "registerLogger", { enumerable: true, get: function () { return logging_1.registerLogger; } });
+var check_1 = require("./core/check");
+Object.defineProperty(exports, "check", { enumerable: true, get: function () { return check_1.check; } });
 var IsographEnvironmentProvider_1 = require("./react/IsographEnvironmentProvider");
 Object.defineProperty(exports, "IsographEnvironmentProvider", { enumerable: true, get: function () { return IsographEnvironmentProvider_1.IsographEnvironmentProvider; } });
 Object.defineProperty(exports, "useIsographEnvironment", { enumerable: true, get: function () { return IsographEnvironmentProvider_1.useIsographEnvironment; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-adb0955b",
+  "version": "0.0.0-main-ba9f1dc0",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -17,9 +17,9 @@
     "tsc": "tsc"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-adb0955b",
-    "@isograph/react-disposable-state": "0.0.0-main-adb0955b",
-    "@isograph/reference-counted-pointer": "0.0.0-main-adb0955b"
+    "@isograph/disposable-types": "0.0.0-main-ba9f1dc0",
+    "@isograph/react-disposable-state": "0.0.0-main-ba9f1dc0",
+    "@isograph/reference-counted-pointer": "0.0.0-main-ba9f1dc0"
   },
   "peerDependencies": {
     "react": "18.3.1"

package/src/core/check.ts

@@ -0,0 +1,194 @@
+import { getParentRecordKey } from './cache';
+import { NormalizationAst } from './entrypoint';
+import { Variables } from './FragmentReference';
+import {
+  getLink,
+  IsographEnvironment,
+  Link,
+  ROOT_ID,
+  StoreRecord,
+} from './IsographEnvironment';
+
+type CheckResult =
+  | {
+      kind: 'EnoughData';
+    }
+  | {
+      kind: 'MissingData';
+      record: Link;
+    };
+
+export function check(
+  environment: IsographEnvironment,
+  normalizationAst: NormalizationAst,
+  variables: Variables,
+): CheckResult {
+  return checkFromRecord(
+    environment,
+    normalizationAst,
+    variables,
+    environment.store[ROOT_ID],
+    ROOT_ID,
+  );
+}
+
+function checkFromRecord(
+  environment: IsographEnvironment,
+  normalizationAst: NormalizationAst,
+  variables: Variables,
+  record: StoreRecord,
+  backupId: string,
+): CheckResult {
+  normalizationAstLoop: for (const normalizationAstNode of normalizationAst) {
+    switch (normalizationAstNode.kind) {
+      case 'Scalar': {
+        const parentRecordKey = getParentRecordKey(
+          normalizationAstNode,
+          variables,
+        );
+        const scalarValue = record[parentRecordKey];
+
+        // null means the value is known to be missing, so it must
+        // be exactly undefined
+        if (scalarValue === undefined) {
+          return {
+            kind: 'MissingData',
+            record: {
+              __link: record.id ?? backupId,
+            },
+          };
+        }
+        continue normalizationAstLoop;
+      }
+      case 'Linked': {
+        const parentRecordKey = getParentRecordKey(
+          normalizationAstNode,
+          variables,
+        );
+
+        const linkedValue = record[parentRecordKey];
+
+        if (linkedValue === undefined) {
+          return {
+            kind: 'MissingData',
+            record: {
+              __link: record.id ?? backupId,
+            },
+          };
+        } else if (linkedValue === null) {
+          continue;
+        } else if (Array.isArray(linkedValue)) {
+          arrayItemsLoop: for (const item of linkedValue) {
+            const link = getLink(item);
+            if (link === null) {
+              throw new Error(
+                'Unexpected non-link in the Isograph store. ' +
+                  'This is indicative of a bug in Isograph.',
+              );
+            }
+
+            const linkedRecord = environment.store[link.__link];
+
+            if (linkedRecord === undefined) {
+              return {
+                kind: 'MissingData',
+                record: link,
+              };
+            } else if (linkedRecord === null) {
+              continue arrayItemsLoop;
+            } else {
+              // TODO in __DEV__ assert linkedRecord is an object
+              const result = checkFromRecord(
+                environment,
+                normalizationAstNode.selections,
+                variables,
+                linkedRecord,
+                // TODO this seems likely to be wrong
+                backupId + '.' + parentRecordKey,
+              );
+
+              if (result.kind === 'MissingData') {
+                return result;
+              }
+            }
+          }
+        } else {
+          const link = getLink(linkedValue);
+          if (link === null) {
+            throw new Error(
+              'Unexpected non-link in the Isograph store. ' +
+                'This is indicative of a bug in Isograph.',
+            );
+          }
+
+          const linkedRecord = environment.store[link.__link];
+
+          if (linkedRecord === undefined) {
+            return {
+              kind: 'MissingData',
+              record: link,
+            };
+          } else if (linkedRecord === null) {
+            continue normalizationAstLoop;
+          } else {
+            // TODO in __DEV__ assert linkedRecord is an object
+            const result = checkFromRecord(
+              environment,
+              normalizationAstNode.selections,
+              variables,
+              linkedRecord,
+              // TODO this seems likely to be wrong
+              backupId + '.' + parentRecordKey,
+            );
+
+            if (result.kind === 'MissingData') {
+              return result;
+            }
+          }
+        }
+
+        continue normalizationAstLoop;
+      }
+      case 'InlineFragment': {
+        const existingRecordTypename = record['__typename'];
+
+        if (
+          existingRecordTypename == null ||
+          existingRecordTypename !== normalizationAstNode.type
+        ) {
+          return {
+            kind: 'MissingData',
+            record: {
+              __link: record.id ?? backupId,
+            },
+          };
+        }
+
+        const result = checkFromRecord(
+          environment,
+          normalizationAstNode.selections,
+          variables,
+          record,
+          backupId,
+        );
+
+        if (result.kind === 'MissingData') {
+          return result;
+        }
+
+        continue normalizationAstLoop;
+      }
+      default: {
+        let _: never = normalizationAstNode;
+        _;
+        throw new Error(
+          'Unexpected case. This is indicative of a bug in Isograph.',
+        );
+      }
+    }
+  }
+
+  return {
+    kind: 'EnoughData',
+  };
+}

package/src/index.ts

@@ -74,6 +74,7 @@ export {
   logMessage,
   registerLogger,
 } from './core/logging';
+export { check } from './core/check';
 
 export {
   IsographEnvironmentProvider,