@isograph/react 0.2.0 → 0.3.0

package/dist/react/useImperativeReference.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useImperativeReference = void 0;
+exports.useImperativeReference = useImperativeReference;
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
 const IsographEnvironment_1 = require("../core/IsographEnvironment");
@@ -12,8 +12,8 @@ function useImperativeReference(entrypoint) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     return {
         fragmentReference: state,
-        loadFragmentReference: (variables) => {
-            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.makeNetworkRequest)(environment, entrypoint, variables);
+        loadFragmentReference: (variables, fetchOptions) => {
+            const [networkRequest, disposeNetworkRequest] = (0, makeNetworkRequest_1.maybeMakeNetworkRequest)(environment, entrypoint, variables, fetchOptions);
             setState([
                 {
                     kind: 'FragmentReference',
@@ -22,7 +22,7 @@ function useImperativeReference(entrypoint) {
                         readerArtifact: entrypoint.readerWithRefetchQueries.readerArtifact,
                         nestedRefetchQueries: entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
                     }),
-                    root: IsographEnvironment_1.ROOT_ID,
+                    root: { __link: IsographEnvironment_1.ROOT_ID, __typename: entrypoint.concreteType },
                     variables,
                     networkRequest,
                 },
@@ -33,4 +33,3 @@ function useImperativeReference(entrypoint) {
         },
     };
 }
-exports.useImperativeReference = useImperativeReference;

package/dist/react/useLazyReference.d.ts

@@ -1,5 +1,10 @@
-import { FragmentReference, Variables } from '../core/FragmentReference';
+import { FragmentReference, ExtractParameters } from '../core/FragmentReference';
 import { IsographEntrypoint } from '../core/entrypoint';
-export declare function useLazyReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: Variables): {
+import { FetchOptions } from '../core/check';
+export declare function useLazyReference<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: ExtractParameters<TReadFromStore>, fetchOptions?: FetchOptions): {
     fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 };
+//# sourceMappingURL=useLazyReference.d.ts.map

package/dist/react/useLazyReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLazyReference.d.ts","sourceRoot":"","sources":["../../src/react/useLazyReference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAIxD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,wBAAgB,gBAAgB,CAC9B,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAC3D,iBAAiB,EAEjB,UAAU,EAAE,kBAAkB,CAAC,cAAc,EAAE,iBAAiB,CAAC,EACjE,SAAS,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAC5C,YAAY,CAAC,EAAE,YAAY,GAC1B;IACD,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;CACzE,CAqBA"}

package/dist/react/useLazyReference.js

@@ -1,14 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLazyReference = void 0;
+exports.useLazyReference = useLazyReference;
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
 const cache_1 = require("../core/cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
-function useLazyReference(entrypoint, variables) {
+const logging_1 = require("../core/logging");
+function useLazyReference(entrypoint, variables, fetchOptions) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
+    if ((entrypoint === null || entrypoint === void 0 ? void 0 : entrypoint.kind) !== 'Entrypoint') {
+        // TODO have a separate error logger
+        (0, logging_1.logMessage)(environment, {
+            kind: 'NonEntrypointReceived',
+            entrypoint,
+        });
+    }
+    const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables, fetchOptions);
     return {
         fragmentReference: (0, react_disposable_state_1.useLazyDisposableState)(cache).state,
     };
 }
-exports.useLazyReference = useLazyReference;

package/dist/react/useReadAndSubscribe.d.ts

@@ -1,11 +1,20 @@
-import { FragmentReference } from '../core/FragmentReference';
+import { FragmentReference, ExtractData } from '../core/FragmentReference';
 import { NetworkRequestReaderOptions, WithEncounteredRecords } from '../core/read';
+import type { ReaderAst } from '../core/reader';
 /**
  * Read the data from a fragment reference and subscribe to updates.
  */
-export declare function useReadAndSubscribe<TReadFromStore extends Object>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions): TReadFromStore;
-export declare function useSubscribeToMultiple<TReadFromStore extends Object>(items: ReadonlyArray<{
+export declare function useReadAndSubscribe<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(fragmentReference: FragmentReference<TReadFromStore, any>, networkRequestOptions: NetworkRequestReaderOptions, readerAst: ReaderAst<TReadFromStore>): ExtractData<TReadFromStore>;
+export declare function useSubscribeToMultiple<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(items: ReadonlyArray<{
     records: WithEncounteredRecords<TReadFromStore>;
     callback: (updatedRecords: WithEncounteredRecords<TReadFromStore>) => void;
     fragmentReference: FragmentReference<TReadFromStore, any>;
+    readerAst: ReaderAst<TReadFromStore>;
 }>): void;
+//# sourceMappingURL=useReadAndSubscribe.d.ts.map

package/dist/react/useReadAndSubscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReadAndSubscribe.d.ts","sourceRoot":"","sources":["../../src/react/useReadAndSubscribe.ts"],"names":[],"mappings":"AACA,OAAO,EACL,iBAAiB,EAEjB,WAAW,EACZ,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,2BAA2B,EAE3B,sBAAsB,EACvB,MAAM,cAAc,CAAC;AAItB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAE3D,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,EACzD,qBAAqB,EAAE,2BAA2B,EAClD,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,GACnC,WAAW,CAAC,cAAc,CAAC,CAY7B;AAED,wBAAgB,sBAAsB,CACpC,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAE3D,KAAK,EAAE,aAAa,CAAC;IACnB,OAAO,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC;IAChD,QAAQ,EAAE,CAAC,cAAc,EAAE,sBAAsB,CAAC,cAAc,CAAC,KAAK,IAAI,CAAC;IAC3E,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;IAC1D,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;CACtC,CAAC,QAiCH"}

package/dist/react/useReadAndSubscribe.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSubscribeToMultiple = exports.useReadAndSubscribe = void 0;
+exports.useReadAndSubscribe = useReadAndSubscribe;
+exports.useSubscribeToMultiple = useSubscribeToMultiple;
 const react_1 = require("react");
 const FragmentReference_1 = require("../core/FragmentReference");
 const read_1 = require("../core/read");
@@ -10,18 +11,17 @@ const cache_1 = require("../core/cache");
 /**
  * Read the data from a fragment reference and subscribe to updates.
  */
-function useReadAndSubscribe(fragmentReference, networkRequestOptions) {
+function useReadAndSubscribe(fragmentReference, networkRequestOptions, readerAst) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     const [readOutDataAndRecords, setReadOutDataAndRecords] = (0, react_1.useState)(() => (0, read_1.readButDoNotEvaluate)(environment, fragmentReference, networkRequestOptions));
-    (0, useRerenderOnChange_1.useRerenderOnChange)(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords);
+    (0, useRerenderOnChange_1.useRerenderOnChange)(readOutDataAndRecords, fragmentReference, setReadOutDataAndRecords, readerAst);
     return readOutDataAndRecords.item;
 }
-exports.useReadAndSubscribe = useReadAndSubscribe;
 function useSubscribeToMultiple(items) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     (0, react_1.useEffect)(() => {
-        const cleanupFns = items.map(({ records, callback, fragmentReference }) => {
-            return (0, cache_1.subscribe)(environment, records, fragmentReference, callback);
+        const cleanupFns = items.map(({ records, callback, fragmentReference, readerAst }) => {
+            return (0, cache_1.subscribe)(environment, records, fragmentReference, callback, readerAst);
         });
         return () => {
             cleanupFns.forEach((loader) => {
@@ -38,4 +38,3 @@ function useSubscribeToMultiple(items) {
             .join('.'),
     ]);
 }
-exports.useSubscribeToMultiple = useSubscribeToMultiple;

package/dist/react/useRerenderOnChange.d.ts

@@ -1,3 +1,8 @@
 import { WithEncounteredRecords } from '../core/read';
 import { FragmentReference } from '../core/FragmentReference';
-export declare function useRerenderOnChange<TReadFromStore extends Object>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void): void;
+import type { ReaderAst } from '../core/reader';
+export declare function useRerenderOnChange<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}>(encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>, fragmentReference: FragmentReference<any, any>, setEncounteredDataAndRecords: (data: WithEncounteredRecords<TReadFromStore>) => void, readerAst: ReaderAst<TReadFromStore>): void;
+//# sourceMappingURL=useRerenderOnChange.d.ts.map

package/dist/react/useRerenderOnChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRerenderOnChange.d.ts","sourceRoot":"","sources":["../../src/react/useRerenderOnChange.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD,wBAAgB,mBAAmB,CACjC,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAE3D,yBAAyB,EAAE,sBAAsB,CAAC,cAAc,CAAC,EACjE,iBAAiB,EAAE,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,EAC9C,4BAA4B,EAAE,CAC5B,IAAI,EAAE,sBAAsB,CAAC,cAAc,CAAC,KACzC,IAAI,EACT,SAAS,EAAE,SAAS,CAAC,cAAc,CAAC,QAoBrC"}

package/dist/react/useRerenderOnChange.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useRerenderOnChange = void 0;
+exports.useRerenderOnChange = useRerenderOnChange;
 const react_1 = require("react");
 const cache_1 = require("../core/cache");
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
 // TODO add unit tests for this. Add integration tests that test
 // behavior when the encounteredRecords underneath a fragment change.
-function useRerenderOnChange(encounteredDataAndRecords, fragmentReference, setEncounteredDataAndRecords) {
+function useRerenderOnChange(encounteredDataAndRecords, fragmentReference, setEncounteredDataAndRecords, readerAst) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
     (0, react_1.useEffect)(() => {
         return (0, cache_1.subscribe)(environment, encounteredDataAndRecords, fragmentReference, (newEncounteredDataAndRecords) => {
             setEncounteredDataAndRecords(newEncounteredDataAndRecords);
-        });
+        }, readerAst);
         // Note: this is an empty array on purpose:
         // - the fragment reference is stable for the life of the component
         // - ownership of encounteredDataAndRecords is transferred into the
@@ -20,4 +20,3 @@ function useRerenderOnChange(encounteredDataAndRecords, fragmentReference, setEn
         //   the dependency array
     }, []);
 }
-exports.useRerenderOnChange = useRerenderOnChange;

package/dist/react/useResult.d.ts

@@ -1,5 +1,9 @@
 import { FragmentReference } from '../core/FragmentReference';
 import { NetworkRequestReaderOptions } from '../core/read';
 import { PromiseWrapper } from '../core/PromiseWrapper';
-export declare function useResult<TReadFromStore extends Object, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
+export declare function useResult<TReadFromStore extends {
+    parameters: object;
+    data: object;
+}, TClientFieldValue>(fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>, partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void): TClientFieldValue;
 export declare function maybeUnwrapNetworkRequest(networkRequest: PromiseWrapper<void, any>, networkRequestOptions: NetworkRequestReaderOptions): void;
+//# sourceMappingURL=useResult.d.ts.map

package/dist/react/useResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResult.d.ts","sourceRoot":"","sources":["../../src/react/useResult.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AACtB,OAAO,EAEL,cAAc,EAEf,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,SAAS,CACvB,cAAc,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAC3D,iBAAiB,EAEjB,iBAAiB,EAAE,iBAAiB,CAAC,cAAc,EAAE,iBAAiB,CAAC,EACvE,4BAA4B,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,GAAG,IAAI,GACzE,iBAAiB,CAqCnB;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,EACzC,qBAAqB,EAAE,2BAA2B,QAWnD"}

package/dist/react/useResult.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeUnwrapNetworkRequest = exports.useResult = void 0;
+exports.useResult = useResult;
+exports.maybeUnwrapNetworkRequest = maybeUnwrapNetworkRequest;
 const IsographEnvironmentProvider_1 = require("../react/IsographEnvironmentProvider");
 const componentCache_1 = require("../core/componentCache");
 const useReadAndSubscribe_1 = require("./useReadAndSubscribe");
@@ -17,12 +18,15 @@ function useResult(fragmentReference, partialNetworkRequestOptions) {
             return (0, componentCache_1.getOrCreateCachedComponent)(environment, readerWithRefetchQueries.readerArtifact.componentName, fragmentReference, networkRequestOptions);
         }
         case 'EagerReaderArtifact': {
-            const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(fragmentReference, networkRequestOptions);
-            return readerWithRefetchQueries.readerArtifact.resolver(data);
+            const data = (0, useReadAndSubscribe_1.useReadAndSubscribe)(fragmentReference, networkRequestOptions, readerWithRefetchQueries.readerArtifact.readerAst);
+            const param = {
+                data: data,
+                parameters: fragmentReference.variables,
+            };
+            return readerWithRefetchQueries.readerArtifact.resolver(param);
         }
     }
 }
-exports.useResult = useResult;
 function maybeUnwrapNetworkRequest(networkRequest, networkRequestOptions) {
     const state = (0, PromiseWrapper_1.getPromiseState)(networkRequest);
     if (state.kind === 'Err' && networkRequestOptions.throwOnNetworkError) {
@@ -33,4 +37,3 @@ function maybeUnwrapNetworkRequest(networkRequest, networkRequestOptions) {
         throw state.promise;
     }
 }
-exports.maybeUnwrapNetworkRequest = maybeUnwrapNetworkRequest;

package/{src/tests/isograph.config.json → isograph.config.json}

@@ -1,5 +1,5 @@
 {
-  "project_root": ".",
+  "project_root": "./src/tests",
   "schema": "./schema.graphql",
   "options": {
     "on_invalid_id_type": "error"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -13,22 +13,26 @@
     "test": "vitest run",
     "test-watch": "vitest watch",
     "coverage": "vitest run --coverage",
-    "prepack": "yarn run test && yarn run compile",
-    "tsc": "tsc"
+    "prepack": "pnpm run test && pnpm run compile",
+    "tsc": "tsc",
+    "iso": "../../target/debug/isograph_cli --config ./isograph.config.json",
+    "iso-watch": "../../target/debug/isograph_cli --config ./isograph.config.json --watch"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.2.0",
+    "@isograph/disposable-types": "*",
     "@isograph/react-disposable-state": "*",
     "@isograph/reference-counted-pointer": "*"
   },
   "peerDependencies": {
-    "react": "18.2.0"
+    "react": "18.3.1"
   },
   "devDependencies": {
-    "@types/react": "^18.0.31",
+    "@babel/preset-typescript": "^7.24.7",
+    "@types/react": "18.3.1",
     "react-test-renderer": "^18.2.0",
-    "vitest": "^0.29.8",
-    "typescript": "^5.0.3"
+    "typescript": "5.6.3",
+    "vite-plugin-babel": "^1.2.0",
+    "vite-plugin-commonjs": "^0.10.1"
   },
   "repository": {
     "type": "git",

package/{src/tests/schema.graphql → schema.graphql}

@@ -2,6 +2,7 @@ type Query {
   me: Economist!
   you: Economist!
   node(id: ID!): Node
+  query: Query!
 }
 
 type Economist implements Node {

package/src/core/FragmentReference.ts

@@ -1,4 +1,4 @@
-import { DataId } from './IsographEnvironment';
+import { type Link } from './IsographEnvironment';
 import { ReaderWithRefetchQueries } from '../core/entrypoint';
 import { PromiseWrapper } from './PromiseWrapper';
 
@@ -7,23 +7,35 @@ export type VariableValue = string | number | boolean | null | object;
 
 export type Variables = { readonly [index: string]: VariableValue };
 
+export type ExtractData<T> = T extends {
+  data: infer D extends object;
+}
+  ? D
+  : never;
+
+export type ExtractParameters<T> = T extends {
+  parameters: infer P extends Variables;
+}
+  ? P
+  : Variables;
+
 export type FragmentReference<
-  TReadFromStore extends Object,
+  TReadFromStore extends { parameters: object; data: object },
   TClientFieldValue,
 > = {
   readonly kind: 'FragmentReference';
   readonly readerWithRefetchQueries: PromiseWrapper<
     ReaderWithRefetchQueries<TReadFromStore, TClientFieldValue>
   >;
-  readonly root: DataId;
-  readonly variables: Variables | null;
+  readonly root: Link;
+  readonly variables: ExtractParameters<TReadFromStore>;
   readonly networkRequest: PromiseWrapper<void, any>;
 };
 
 export function stableIdForFragmentReference(
   fragmentReference: FragmentReference<any, any>,
 ): string {
-  return `${fragmentReference.root}/TODO_FRAGMENT_NAME/${serializeVariables(fragmentReference.variables ?? {})}`;
+  return `${fragmentReference.root.__typename}/${fragmentReference.root.__link}/TODO_FRAGMENT_NAME/${serializeVariables(fragmentReference.variables ?? {})}`;
 }
 
 function serializeVariables(variables: Variables) {

package/src/core/IsographEnvironment.ts

@@ -4,6 +4,8 @@ import { WithEncounteredRecords } from './read';
 import { FragmentReference, Variables } from './FragmentReference';
 import { PromiseWrapper, wrapPromise } from './PromiseWrapper';
 import { IsographEntrypoint } from './entrypoint';
+import type { ReaderAst } from './reader';
+import { LogFunction, WrappedLogFunction } from './logging';
 
 export type ComponentOrFieldName = string;
 export type StringifiedArgs = string;
@@ -13,7 +15,9 @@ type ComponentCache = {
   };
 };
 
-export type FragmentSubscription<TReadFromStore extends Object> = {
+export type FragmentSubscription<
+  TReadFromStore extends { parameters: object; data: object },
+> = {
   readonly kind: 'FragmentSubscription';
   readonly callback: (
     newEncounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
@@ -21,13 +25,24 @@ export type FragmentSubscription<TReadFromStore extends Object> = {
   /** The value read out from the previous call to readButDoNotEvaluate */
   readonly encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>;
   readonly fragmentReference: FragmentReference<TReadFromStore, any>;
+  readonly readerAst: ReaderAst<TReadFromStore>;
 };
+
+type AnyChangesToRecordSubscription = {
+  readonly kind: 'AnyChangesToRecord';
+  readonly callback: () => void;
+  readonly recordLink: Link;
+};
+
 type AnyRecordSubscription = {
   readonly kind: 'AnyRecords';
   readonly callback: () => void;
 };
 
-type Subscription = FragmentSubscription<Object> | AnyRecordSubscription;
+type Subscription =
+  | FragmentSubscription<{ parameters: object; data: object }>
+  | AnyChangesToRecordSubscription
+  | AnyRecordSubscription;
 type Subscriptions = Set<Subscription>;
 // Should this be a map?
 type CacheMap<T> = { [index: string]: ParentCache<T> };
@@ -49,11 +64,12 @@ export type IsographEnvironment = {
   readonly retainedQueries: Set<RetainedQuery>;
   readonly gcBuffer: Array<RetainedQuery>;
   readonly gcBufferSize: number;
+  readonly loggers: Set<WrappedLogFunction>;
 };
 
 export type MissingFieldHandler = (
   storeRecord: StoreRecord,
-  root: DataId,
+  root: Link,
   fieldName: string,
   arguments_: { [index: string]: any } | null,
   variables: Variables | null,
@@ -66,6 +82,7 @@ export type IsographNetworkFunction = (
 
 export type Link = {
   readonly __link: DataId;
+  readonly __typename: TypeName;
 };
 
 export type DataTypeValue =
@@ -89,20 +106,26 @@ export type StoreRecord = {
   readonly id?: DataId;
 };
 
+export type TypeName = string;
 export type DataId = string;
 
 export const ROOT_ID: DataId & '__ROOT' = '__ROOT';
 
 export type IsographStore = {
-  [index: DataId]: StoreRecord | null;
-  readonly __ROOT: StoreRecord;
+  [index: TypeName]: {
+    [index: DataId]: StoreRecord | null;
+  } | null;
+  readonly Query: {
+    readonly __ROOT: StoreRecord;
+  };
 };
 
 const DEFAULT_GC_BUFFER_SIZE = 10;
 export function createIsographEnvironment(
   store: IsographStore,
   networkFunction: IsographNetworkFunction,
-  missingFieldHandler?: MissingFieldHandler,
+  missingFieldHandler?: MissingFieldHandler | null,
+  logFunction?: LogFunction | null,
 ): IsographEnvironment {
   return {
     store,
@@ -115,34 +138,18 @@ export function createIsographEnvironment(
     retainedQueries: new Set(),
     gcBuffer: [],
     gcBufferSize: DEFAULT_GC_BUFFER_SIZE,
+    loggers: logFunction != null ? new Set([{ log: logFunction }]) : new Set(),
   };
 }
 
 export function createIsographStore(): IsographStore {
   return {
-    [ROOT_ID]: {},
+    Query: {
+      [ROOT_ID]: {},
+    },
   };
 }
 
-export function defaultMissingFieldHandler(
-  _storeRecord: StoreRecord,
-  _root: DataId,
-  fieldName: string,
-  arguments_: { [index: string]: any } | null,
-  variables: Variables | null,
-): Link | undefined {
-  if (fieldName === 'node' || fieldName === 'user') {
-    const variable = arguments_?.['id'];
-    const value = variables?.[variable];
-
-    // TODO can we handle explicit nulls here too? Probably, after wrapping in objects
-    if (value != null) {
-      // @ts-expect-error
-      return { __link: value };
-    }
-  }
-}
-
 export function assertLink(link: DataTypeValue): Link | null | undefined {
   if (Array.isArray(link)) {
     throw new Error('Unexpected array');
@@ -160,10 +167,12 @@ export function getLink(maybeLink: DataTypeValue): Link | null {
   if (
     maybeLink != null &&
     typeof maybeLink === 'object' &&
-    // @ts-expect-error this is safe
-    maybeLink.__link != null
+    '__link' in maybeLink &&
+    maybeLink.__link != null &&
+    '__typename' in maybeLink &&
+    maybeLink.__typename != null
   ) {
-    return maybeLink as any;
+    return maybeLink;
   }
   return null;
 }

package/src/core/areEqualWithDeepComparison.ts

@@ -1,78 +1,112 @@
-export function areEqualWithDeepComparison(
+import type { ReaderAst, ReaderLinkedField, ReaderScalarField } from './reader';
+export function mergeUsingReaderAst(
+  field: ReaderScalarField | ReaderLinkedField,
   oldItem: unknown,
   newItem: unknown,
-): boolean {
+): unknown {
   if (newItem === null) {
-    return oldItem === null;
+    return oldItem === null ? oldItem : newItem;
   }
 
   if (newItem === undefined) {
-    return oldItem === undefined;
+    return oldItem === undefined ? oldItem : newItem;
   }
 
   if (Array.isArray(newItem)) {
     if (!Array.isArray(oldItem)) {
-      return false;
+      return newItem;
     }
 
-    return areEqualArraysWithDeepComparison(oldItem, newItem);
+    return mergeArraysUsingReaderAst(field, oldItem, newItem);
   }
 
-  if (typeof newItem === 'object') {
-    if (typeof oldItem !== 'object') {
-      return false;
-    }
+  switch (field.kind) {
+    case 'Scalar':
+      return oldItem === newItem ? oldItem : newItem;
+    case 'Linked':
+      if (oldItem == null) {
+        return newItem;
+      }
 
-    if (oldItem === null) {
-      return false;
+      return mergeObjectsUsingReaderAst(field.selections, oldItem, newItem);
+    default: {
+      // Ensure we have covered all variants
+      let _: never = field;
+      _;
+      throw new Error('Unexpected case.');
     }
-
-    return areEqualObjectsWithDeepComparison(oldItem, newItem);
   }
-
-  return newItem === oldItem;
 }
 
-export function areEqualArraysWithDeepComparison(
+export function mergeArraysUsingReaderAst(
+  field: ReaderScalarField | ReaderLinkedField,
   oldItems: ReadonlyArray<unknown>,
-  newItems: ReadonlyArray<unknown>,
-): boolean {
+  newItems: Array<unknown>,
+): ReadonlyArray<unknown> {
   if (newItems.length !== oldItems.length) {
-    return false;
+    return newItems;
   }
 
+  let canRecycle = true;
   for (let i = 0; i < newItems.length; i++) {
-    if (!areEqualWithDeepComparison(oldItems[i], newItems[i])) {
-      return false;
+    const mergedItem = mergeUsingReaderAst(field, oldItems[i], newItems[i]);
+    if (mergedItem !== oldItems[i]) {
+      canRecycle = false;
+    } else {
+      newItems[i] = mergedItem;
     }
   }
 
-  return true;
+  return canRecycle ? oldItems : newItems;
 }
 
-export function areEqualObjectsWithDeepComparison(
+export function mergeObjectsUsingReaderAst(
+  ast: ReaderAst<object>,
   oldItemObject: object,
   newItemObject: object,
-): boolean {
-  const oldKeys = Object.keys(oldItemObject);
-  const newKeys = Object.keys(newItemObject);
+): object {
+  let canRecycle = true;
+  for (const field of ast) {
+    switch (field.kind) {
+      case 'Scalar':
+      case 'Linked':
+        const key = field.alias ?? field.fieldName;
+        // @ts-expect-error
+        const oldValue = oldItemObject[key];
+        // @ts-expect-error
+        const newValue = newItemObject[key];
 
-  if (oldKeys.length !== newKeys.length) {
-    return false;
-  }
+        const mergedValue = mergeUsingReaderAst(field, oldValue, newValue);
+        if (mergedValue !== oldValue) {
+          canRecycle = false;
+        } else {
+          // @ts-expect-error
+          newItemObject[key] = mergedValue;
+        }
+        break;
+      case 'Resolver': {
+        const key = field.alias;
+        // @ts-expect-error
+        const oldValue = oldItemObject[key];
+        // @ts-expect-error
+        const newValue = newItemObject[key];
 
-  for (const oldKey of oldKeys) {
-    if (!(oldKey in newItemObject)) {
-      return false;
-    }
-    // @ts-expect-error
-    const oldValue = oldItemObject[oldKey];
-    // @ts-expect-error
-    const newValue = newItemObject[oldKey];
-
-    if (!areEqualWithDeepComparison(oldValue, newValue)) {
-      return false;
+        if (oldValue !== newValue) {
+          canRecycle = false;
+        }
+        break;
+      }
+      case 'ImperativelyLoadedField':
+      case 'LoadablySelectedField':
+        break;
+      default: {
+        // Ensure we have covered all variants
+        let _: never = field;
+        _;
+        throw new Error('Unexpected case.');
+      }
     }
   }
-  return true;
+
+  return canRecycle ? oldItemObject : newItemObject;
 }