@isograph/react 0.0.0-main-2f494978 → 0.0.0-main-6b81bb01

package/dist/cache.d.ts

@@ -15,7 +15,7 @@ declare global {
  */
 export declare function stableCopy<T>(value: T): T;
 type IsoResolver = IsographEntrypoint<any, any>;
-export declare function getOrCreateCacheForArtifact<T>(environment: IsographEnvironment, artifact: IsographEntrypoint<any, T>, variables: object): ParentCache<PromiseWrapper<T>>;
+export declare function getOrCreateCacheForArtifact<TReadFromStore extends Object, TClientFieldValue>(environment: IsographEnvironment, artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: object): ParentCache<PromiseWrapper<TClientFieldValue>>;
 export declare function makeNetworkRequest<T>(environment: IsographEnvironment, artifact: IsoResolver, variables: object): ItemCleanupPair<PromiseWrapper<T>>;
 export declare function subscribe(environment: IsographEnvironment, callback: () => void): () => void;
 export declare function onNextChange(environment: IsographEnvironment): Promise<void>;

package/dist/useImperativeReference.d.ts

@@ -1,8 +1,8 @@
 import { UnassignedState } from '@isograph/react-disposable-state';
-import { ExtractReadFromStore, ExtractResolverResult, IsographEntrypoint } from './entrypoint';
+import { IsographEntrypoint } from './entrypoint';
 import { FragmentReference } from './FragmentReference';
-export declare function useImperativeReference<TEntrypoint extends IsographEntrypoint<any, any>>(entrypoint: TEntrypoint): {
-    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>> | UnassignedState;
+export declare function useImperativeReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>): {
+    queryReference: FragmentReference<TReadFromStore, TClientFieldValue> | UnassignedState;
     loadQueryReference: (variables: {
         [index: string]: string;
     }) => void;

package/dist/useLazyReference.d.ts

@@ -1,7 +1,7 @@
 import { FragmentReference, Variable } from './FragmentReference';
-import { ExtractReadFromStore, ExtractResolverResult } from './entrypoint';
-export declare function useLazyReference<TEntrypoint>(entrypoint: TEntrypoint | ((_: any) => any), variables: {
+import { IsographEntrypoint } from './entrypoint';
+export declare function useLazyReference<TReadFromStore extends Object, TClientFieldValue>(entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>, variables: {
     [key: string]: Variable;
 }): {
-    queryReference: FragmentReference<ExtractReadFromStore<TEntrypoint>, ExtractResolverResult<TEntrypoint>>;
+    queryReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 };

package/dist/useLazyReference.js

@@ -3,20 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLazyReference = void 0;
 const IsographEnvironmentProvider_1 = require("./IsographEnvironmentProvider");
 const IsographEnvironment_1 = require("./IsographEnvironment");
-const entrypoint_1 = require("./entrypoint");
 const cache_1 = require("./cache");
 const react_disposable_state_1 = require("@isograph/react-disposable-state");
-// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
-// if we do not explicitly pass a type, the read out type will be any.
-// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
-// any actual Entrypoint we pass will not be valid.
 function useLazyReference(entrypoint, variables) {
     const environment = (0, IsographEnvironmentProvider_1.useIsographEnvironment)();
-    (0, entrypoint_1.assertIsEntrypoint)(entrypoint);
     const cache = (0, cache_1.getOrCreateCacheForArtifact)(environment, entrypoint, variables);
     // TODO add comment explaining why we never use this value
-    // @ts-ignore
-    const data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
+    // @ts-ignore(6133)
+    const _data = (0, react_disposable_state_1.useLazyDisposableState)(cache).state;
     return {
         queryReference: {
             kind: 'FragmentReference',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react",
-  "version": "0.0.0-main-2f494978",
+  "version": "0.0.0-main-6b81bb01",
   "description": "Use Isograph with React",
   "homepage": "https://isograph.dev",
   "main": "dist/index.js",
@@ -10,14 +10,14 @@
   "scripts": {
     "compile": "rm -rf dist/* && tsc -p tsconfig.pkg.json",
     "compile-watch": "tsc -p tsconfig.pkg.json --watch",
-    "test": "echo no tests yet",
+    "test": "vitest run",
     "test-watch": "vitest watch",
     "coverage": "vitest run --coverage",
     "prepack": "yarn run test && yarn run compile"
   },
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-2f494978",
-    "@isograph/react-disposable-state": "0.0.0-main-2f494978",
+    "@isograph/disposable-types": "0.0.0-main-6b81bb01",
+    "@isograph/react-disposable-state": "0.0.0-main-6b81bb01",
     "react": "^18.2.0"
   },
   "devDependencies": {

package/src/cache.ts

@@ -76,15 +76,22 @@ export function stableCopy<T>(value: T): T {
 
 type IsoResolver = IsographEntrypoint<any, any>;
 
-export function getOrCreateCacheForArtifact<T>(
+export function getOrCreateCacheForArtifact<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+>(
   environment: IsographEnvironment,
-  artifact: IsographEntrypoint<any, T>,
+  artifact: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
   variables: object,
-): ParentCache<PromiseWrapper<T>> {
+): ParentCache<PromiseWrapper<TClientFieldValue>> {
   const cacheKey = artifact.queryText + JSON.stringify(stableCopy(variables));
-  const factory: Factory<PromiseWrapper<T>> = () =>
-    makeNetworkRequest<T>(environment, artifact, variables);
-  return getOrCreateCache<PromiseWrapper<T>>(environment, cacheKey, factory);
+  const factory: Factory<PromiseWrapper<TClientFieldValue>> = () =>
+    makeNetworkRequest<TClientFieldValue>(environment, artifact, variables);
+  return getOrCreateCache<PromiseWrapper<TClientFieldValue>>(
+    environment,
+    cacheKey,
+    factory,
+  );
 }
 
 type NetworkRequestStatus =

package/src/tests/__isograph/Query/meName/entrypoint.ts

@@ -0,0 +1,43 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {Query__meName__param, Query__meName__outputType} from './reader';
+import readerResolver from './reader';
+const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+
+const queryText = 'query meName  {\
+  me {\
+    id,\
+    name,\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    arguments: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        arguments: null,
+      },
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        arguments: null,
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__meName__param,
+  Query__meName__outputType
+> = {
+  kind: "Entrypoint",
+  queryText,
+  normalizationAst,
+  nestedRefetchQueries,
+  readerArtifact: readerResolver,
+};
+
+export default artifact;

package/src/tests/__isograph/Query/meName/reader.ts

@@ -0,0 +1,40 @@
+import type {ReaderArtifact, ReaderAst, ExtractSecondParam} from '@isograph/react';
+import { meNameField as resolver } from '../../../garbageCollection.test.ts';
+
+// the type, when read out (either via useLazyReference or via graph)
+export type Query__meName__outputType = ReturnType<typeof resolver>;
+
+const readerAst: ReaderAst<Query__meName__param> = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    alias: null,
+    arguments: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        alias: null,
+        arguments: null,
+      },
+    ],
+  },
+];
+
+export type Query__meName__param = {
+  me: {
+    name: string,
+  },
+};
+
+const artifact: ReaderArtifact<
+  Query__meName__param,
+  Query__meName__outputType
+> = {
+  kind: "ReaderArtifact",
+  resolver: resolver as any,
+  readerAst,
+  variant: { kind: "Eager" },
+};
+
+export default artifact;

package/src/tests/__isograph/Query/meNameSuccessor/entrypoint.ts

@@ -0,0 +1,79 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {Query__meNameSuccessor__param, Query__meNameSuccessor__outputType} from './reader';
+import readerResolver from './reader';
+const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+
+const queryText = 'query meNameSuccessor  {\
+  me {\
+    id,\
+    name,\
+    successor {\
+      id,\
+      successor {\
+        id,\
+        name,\
+      },\
+    },\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    arguments: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        arguments: null,
+      },
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        arguments: null,
+      },
+      {
+        kind: "Linked",
+        fieldName: "successor",
+        arguments: null,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            arguments: null,
+          },
+          {
+            kind: "Linked",
+            fieldName: "successor",
+            arguments: null,
+            selections: [
+              {
+                kind: "Scalar",
+                fieldName: "id",
+                arguments: null,
+              },
+              {
+                kind: "Scalar",
+                fieldName: "name",
+                arguments: null,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__meNameSuccessor__param,
+  Query__meNameSuccessor__outputType
+> = {
+  kind: "Entrypoint",
+  queryText,
+  normalizationAst,
+  nestedRefetchQueries,
+  readerArtifact: readerResolver,
+};
+
+export default artifact;

package/src/tests/__isograph/Query/meNameSuccessor/reader.ts

@@ -0,0 +1,67 @@
+import type {ReaderArtifact, ReaderAst, ExtractSecondParam} from '@isograph/react';
+import { meNameField as resolver } from '../../../meNameSuccessor.ts';
+
+// the type, when read out (either via useLazyReference or via graph)
+export type Query__meNameSuccessor__outputType = ReturnType<typeof resolver>;
+
+const readerAst: ReaderAst<Query__meNameSuccessor__param> = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    alias: null,
+    arguments: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        alias: null,
+        arguments: null,
+      },
+      {
+        kind: "Linked",
+        fieldName: "successor",
+        alias: null,
+        arguments: null,
+        selections: [
+          {
+            kind: "Linked",
+            fieldName: "successor",
+            alias: null,
+            arguments: null,
+            selections: [
+              {
+                kind: "Scalar",
+                fieldName: "name",
+                alias: null,
+                arguments: null,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+];
+
+export type Query__meNameSuccessor__param = {
+  me: {
+    name: string,
+    successor: ({
+      successor: ({
+        name: string,
+      } | null),
+    } | null),
+  },
+};
+
+const artifact: ReaderArtifact<
+  Query__meNameSuccessor__param,
+  Query__meNameSuccessor__outputType
+> = {
+  kind: "ReaderArtifact",
+  resolver: resolver as any,
+  readerAst,
+  variant: { kind: "Eager" },
+};
+
+export default artifact;

package/src/tests/__isograph/Query/nodeField/entrypoint.ts

@@ -0,0 +1,42 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {Query__nodeField__param, Query__nodeField__outputType} from './reader';
+import readerResolver from './reader';
+const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+
+const queryText = 'query nodeField ($id: ID!) {\
+  node____id___v_id: node(id: $id) {\
+    id,\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "node",
+    arguments: [
+      [
+        "id",
+        { kind: "Variable", name: "id" },
+      ],
+    ],
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        arguments: null,
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__nodeField__param,
+  Query__nodeField__outputType
+> = {
+  kind: "Entrypoint",
+  queryText,
+  normalizationAst,
+  nestedRefetchQueries,
+  readerArtifact: readerResolver,
+};
+
+export default artifact;

package/src/tests/__isograph/Query/nodeField/reader.ts

@@ -0,0 +1,45 @@
+import type {ReaderArtifact, ReaderAst, ExtractSecondParam} from '@isograph/react';
+import { nodeField as resolver } from '../../../nodeQuery.ts';
+
+// the type, when read out (either via useLazyReference or via graph)
+export type Query__nodeField__outputType = ReturnType<typeof resolver>;
+
+const readerAst: ReaderAst<Query__nodeField__param> = [
+  {
+    kind: "Linked",
+    fieldName: "node",
+    alias: null,
+    arguments: [
+      [
+        "id",
+        { kind: "Variable", name: "id" },
+      ],
+    ],
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        alias: null,
+        arguments: null,
+      },
+    ],
+  },
+];
+
+export type Query__nodeField__param = {
+  node: ({
+    id: string,
+  } | null),
+};
+
+const artifact: ReaderArtifact<
+  Query__nodeField__param,
+  Query__nodeField__outputType
+> = {
+  kind: "ReaderArtifact",
+  resolver: resolver as any,
+  readerAst,
+  variant: { kind: "Eager" },
+};
+
+export default artifact;

package/src/tests/__isograph/iso.ts

@@ -0,0 +1,60 @@
+import type {IsographEntrypoint} from '@isograph/react';
+import { Query__meNameSuccessor__param } from './Query/meNameSuccessor/reader'
+import { Query__meName__param } from './Query/meName/reader'
+import { Query__nodeField__param } from './Query/nodeField/reader'
+import entrypoint_Query__meNameSuccessor from '../__isograph/Query/meNameSuccessor/entrypoint'
+import entrypoint_Query__meName from '../__isograph/Query/meName/entrypoint'
+import entrypoint_Query__nodeField from '../__isograph/Query/nodeField/entrypoint'
+
+type IdentityWithParam<TParam> = <TResolverReturn>(
+  x: (param: TParam) => TResolverReturn
+) => (param: TParam) => TResolverReturn;
+type IdentityWithParamComponent<TParam> = <TResolverReturn, TSecondParam = Record<string, never>>(
+  x: (data: TParam, secondParam: TSecondParam) => TResolverReturn
+) => (data: TParam, secondParam: TSecondParam) => TResolverReturn;
+
+type WhitespaceCharacter = ' ' | '\t' | '\n';
+type Whitespace<In> = In extends `${WhitespaceCharacter}${infer In}`
+  ? Whitespace<In>
+  : In;
+
+type MatchesWhitespaceAndString<
+  TString extends string,
+  T
+> = Whitespace<T> extends `${TString}${string}` ? T : never;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.meNameSuccessor', T>
+): IdentityWithParam<Query__meNameSuccessor__param>;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.meName', T>
+): IdentityWithParam<Query__meName__param>;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.nodeField', T>
+): IdentityWithParam<Query__nodeField__param>;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.meNameSuccessor', T>
+): typeof entrypoint_Query__meNameSuccessor;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.meName', T>
+): typeof entrypoint_Query__meName;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.nodeField', T>
+): typeof entrypoint_Query__nodeField;
+
+export function iso(_isographLiteralText: string):
+  | IdentityWithParam<any>
+  | IdentityWithParamComponent<any>
+  | IsographEntrypoint<any, any>
+{
+  return function identity<TResolverReturn>(
+    clientFieldOrEntrypoint: (param: any) => TResolverReturn,
+  ): (param: any) => TResolverReturn {
+    return clientFieldOrEntrypoint;
+  };
+}

package/src/tests/garbageCollection.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect } from 'vitest';
+import { ROOT_ID, createIsographEnvironment } from '../IsographEnvironment';
+import { garbageCollectEnvironment, retainQuery } from '../garbageCollection';
+import { iso } from './__isograph/iso';
+import { nodeFieldRetainedQuery } from './nodeQuery';
+
+const getDefaultStore = () => ({
+  [ROOT_ID]: {
+    me: { __link: '0' },
+    you: { __link: '1' },
+    node____id___0: {
+      __link: '0',
+    },
+  },
+  0: {
+    __typename: 'Economist',
+    id: '0',
+    name: 'Jeremy Bentham',
+    successor: { __link: '1' },
+  },
+  1: {
+    __typename: 'Economist',
+    id: '1',
+    name: 'John Stuart Mill',
+    predecessor: { __link: '0' },
+    successor: { __link: '2' },
+  },
+  2: {
+    __typename: 'Economist',
+    id: '2',
+    name: 'Henry Sidgwick',
+    predecessor: { __link: '1' },
+  },
+});
+
+export const meNameField = iso(`
+  field Query.meName {
+    me {
+      name
+    }
+  }
+`)(() => {});
+import meNameEntrypoint from './__isograph/Query/meName/entrypoint';
+import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
+iso(`entrypoint Query.meName`);
+const meNameRetainedQuery = {
+  normalizationAst: meNameEntrypoint.normalizationAst,
+  variables: {},
+};
+
+describe('garbage collection', () => {
+  test('Unreferenced records should be garbage collected', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[1]).not.toBe(undefined);
+
+    // TODO enable babel so we don't have to do this
+    retainQuery(environment, meNameRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[1]).toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[0]).not.toBe(undefined);
+
+    // TODO enable babel so we don't have to do this
+    retainQuery(environment, meNameRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected, and this should work with variables', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[0]).not.toBe(undefined);
+
+    retainQuery(environment, nodeFieldRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected, and this should work through multiple levels', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    retainQuery(environment, meNameSuccessorRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+    expect(store[1]).not.toBe(undefined);
+    expect(store[2]).not.toBe(undefined);
+  });
+
+  test('ROOT_ID should not be garbage collected, even if there are no retained queries', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+    garbageCollectEnvironment(environment);
+
+    expect(store[ROOT_ID]).not.toBe(undefined);
+    expect(store[0]).toBe(undefined);
+  });
+});

package/src/tests/isograph.config.json

@@ -0,0 +1,7 @@
+{
+  "project_root": ".",
+  "schema": "./schema.graphql",
+  "options": {
+    "on_invalid_id_type": "error"
+  }
+}

package/src/tests/meNameSuccessor.ts

@@ -0,0 +1,20 @@
+import { iso } from './__isograph/iso';
+
+export const meNameField = iso(`
+  field Query.meNameSuccessor {
+    me {
+      name
+      successor {
+        successor {
+          name
+        }
+      }
+    }
+  }
+`)(() => {});
+import meNameSuccessorEntrypoint from './__isograph/Query/meNameSuccessor/entrypoint';
+iso(`entrypoint Query.meNameSuccessor`);
+export const meNameSuccessorRetainedQuery = {
+  normalizationAst: meNameSuccessorEntrypoint.normalizationAst,
+  variables: {},
+};

package/src/tests/nodeQuery.ts

@@ -0,0 +1,17 @@
+import { iso } from './__isograph/iso';
+
+// TODO investigate why this can't be in garbageCollection.test.ts without
+// typescript incorrectly thinking it is referenced in its own initializer
+export const nodeField = iso(`
+  field Query.nodeField($id: ID!) {
+    node(id: $id) {
+      id
+    }
+  }
+`)(() => {});
+import nodeFieldEntrypoint from './__isograph/Query/nodeField/entrypoint';
+iso(`entrypoint Query.nodeField`);
+export const nodeFieldRetainedQuery = {
+  normalizationAst: nodeFieldEntrypoint.normalizationAst,
+  variables: { id: 0 },
+};

package/src/tests/schema.graphql

@@ -0,0 +1,16 @@
+type Query {
+  me: Economist!
+  you: Economist!
+  node(id: ID!): Node
+}
+
+type Economist implements Node {
+  id: ID!
+  name: String!
+  predecessor: Economist
+  successor: Economist
+}
+
+interface Node {
+  id: ID!
+}

package/src/tests/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "@isograph/react": ["../index.ts"],
+    },
+  },
+}

package/src/useImperativeReference.ts

@@ -2,35 +2,26 @@ import {
   UnassignedState,
   useUpdatableDisposableState,
 } from '@isograph/react-disposable-state';
-import {
-  ExtractReadFromStore,
-  ExtractResolverResult,
-  IsographEntrypoint,
-} from './entrypoint';
+import { IsographEntrypoint } from './entrypoint';
 import { FragmentReference } from './FragmentReference';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 import { makeNetworkRequest } from './cache';
 import { ROOT_ID } from './IsographEnvironment';
 
 export function useImperativeReference<
-  TEntrypoint extends IsographEntrypoint<any, any>,
+  TReadFromStore extends Object,
+  TClientFieldValue,
 >(
-  entrypoint: TEntrypoint,
+  entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
 ): {
   queryReference:
-    | FragmentReference<
-        ExtractReadFromStore<TEntrypoint>,
-        ExtractResolverResult<TEntrypoint>
-      >
+    | FragmentReference<TReadFromStore, TClientFieldValue>
     | UnassignedState;
   loadQueryReference: (variables: { [index: string]: string }) => void;
 } {
   const { state, setState } =
     useUpdatableDisposableState<
-      FragmentReference<
-        ExtractReadFromStore<TEntrypoint>,
-        ExtractResolverResult<TEntrypoint>
-      >
+      FragmentReference<TReadFromStore, TClientFieldValue>
     >();
   const environment = useIsographEnvironment();
   return {

package/src/useLazyReference.ts

@@ -1,50 +1,25 @@
 import { FragmentReference, Variable } from './FragmentReference';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
 import { ROOT_ID } from './IsographEnvironment';
-import {
-  ExtractReadFromStore,
-  ExtractResolverResult,
-  assertIsEntrypoint,
-} from './entrypoint';
+import { IsographEntrypoint } from './entrypoint';
 import { getOrCreateCacheForArtifact } from './cache';
 import { useLazyDisposableState } from '@isograph/react-disposable-state';
-import { type PromiseWrapper } from './PromiseWrapper';
 
-// Note: we cannot write TEntrypoint extends IsographEntrypoint<any, any, any>, or else
-// if we do not explicitly pass a type, the read out type will be any.
-// We cannot write TEntrypoint extends IsographEntrypoint<never, never, never>, or else
-// any actual Entrypoint we pass will not be valid.
-export function useLazyReference<TEntrypoint>(
-  entrypoint:
-    | TEntrypoint
-    // Temporarily, we need to allow useLazyReference to take the result of calling
-    // iso(`...`). At runtime, we confirm that the passed-in `iso` literal is actually
-    // an entrypoint.
-    | ((_: any) => any),
+export function useLazyReference<
+  TReadFromStore extends Object,
+  TClientFieldValue,
+>(
+  entrypoint: IsographEntrypoint<TReadFromStore, TClientFieldValue>,
   variables: { [key: string]: Variable },
 ): {
-  queryReference: FragmentReference<
-    ExtractReadFromStore<TEntrypoint>,
-    ExtractResolverResult<TEntrypoint>
-  >;
+  queryReference: FragmentReference<TReadFromStore, TClientFieldValue>;
 } {
   const environment = useIsographEnvironment();
-  assertIsEntrypoint<
-    ExtractReadFromStore<TEntrypoint>,
-    ExtractResolverResult<TEntrypoint>
-  >(entrypoint);
-  const cache = getOrCreateCacheForArtifact<ExtractResolverResult<TEntrypoint>>(
-    environment,
-    entrypoint,
-    variables,
-  );
+  const cache = getOrCreateCacheForArtifact(environment, entrypoint, variables);
 
   // TODO add comment explaining why we never use this value
-  // @ts-ignore
-  const data =
-    useLazyDisposableState<PromiseWrapper<ExtractResolverResult<TEntrypoint>>>(
-      cache,
-    ).state;
+  // @ts-ignore(6133)
+  const _data = useLazyDisposableState(cache).state;
 
   return {
     queryReference: {

package/tsconfig.pkg.json

@@ -7,5 +7,6 @@
     "jsx": "react",
     "lib": ["es2017", "DOM"]
   },
-  "include": ["./**/*.ts", "./**/*.tsx"]
+  "include": ["./**/*.ts", "./**/*.tsx"],
+  "exclude": ["./src/tests/**/*"]
 }