@isograph/react 0.2.0 → 0.3.0

package/src/react/useResult.ts

@@ -12,7 +12,10 @@ import {
   readPromise,
 } from '../core/PromiseWrapper';
 
-export function useResult<TReadFromStore extends Object, TClientFieldValue>(
+export function useResult<
+  TReadFromStore extends { parameters: object; data: object },
+  TClientFieldValue,
+>(
   fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>,
   partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void,
 ): TClientFieldValue {
@@ -43,8 +46,13 @@ export function useResult<TReadFromStore extends Object, TClientFieldValue>(
       const data = useReadAndSubscribe(
         fragmentReference,
         networkRequestOptions,
+        readerWithRefetchQueries.readerArtifact.readerAst,
       );
-      return readerWithRefetchQueries.readerArtifact.resolver(data);
+      const param = {
+        data: data,
+        parameters: fragmentReference.variables,
+      };
+      return readerWithRefetchQueries.readerArtifact.resolver(param);
     }
   }
 }

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

@@ -16,6 +16,7 @@ const normalizationAst: NormalizationAst = [
     kind: "Linked",
     fieldName: "me",
     arguments: null,
+    concreteType: "Economist",
     selections: [
       {
         kind: "Scalar",
@@ -35,8 +36,12 @@ const artifact: IsographEntrypoint<
   Query__meName__output_type
 > = {
   kind: "Entrypoint",
-  queryText,
-  normalizationAst,
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

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

@@ -1,6 +1,9 @@
 
 export type Query__meName__param = {
-  me: {
-    name: string,
+  readonly data: {
+    readonly me: {
+      readonly name: string,
+    },
   },
+  readonly parameters: Record<PropertyKey, never>,
 };

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

@@ -9,6 +9,7 @@ const readerAst: ReaderAst<Query__meName__param> = [
     fieldName: "me",
     alias: null,
     arguments: null,
+    condition: null,
     selections: [
       {
         kind: "Scalar",

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

@@ -23,6 +23,7 @@ const normalizationAst: NormalizationAst = [
     kind: "Linked",
     fieldName: "me",
     arguments: null,
+    concreteType: "Economist",
     selections: [
       {
         kind: "Scalar",
@@ -38,6 +39,7 @@ const normalizationAst: NormalizationAst = [
         kind: "Linked",
         fieldName: "successor",
         arguments: null,
+        concreteType: "Economist",
         selections: [
           {
             kind: "Scalar",
@@ -48,6 +50,7 @@ const normalizationAst: NormalizationAst = [
             kind: "Linked",
             fieldName: "successor",
             arguments: null,
+            concreteType: "Economist",
             selections: [
               {
                 kind: "Scalar",
@@ -71,8 +74,12 @@ const artifact: IsographEntrypoint<
   Query__meNameSuccessor__output_type
 > = {
   kind: "Entrypoint",
-  queryText,
-  normalizationAst,
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

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

@@ -1,11 +1,14 @@
 
 export type Query__meNameSuccessor__param = {
-  me: {
-    name: string,
-    successor: ({
-      successor: ({
-        name: string,
+  readonly data: {
+    readonly me: {
+      readonly name: string,
+      readonly successor: ({
+        readonly successor: ({
+          readonly name: string,
+        } | null),
       } | null),
-    } | null),
+    },
   },
+  readonly parameters: Record<PropertyKey, never>,
 };

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

@@ -9,6 +9,7 @@ const readerAst: ReaderAst<Query__meNameSuccessor__param> = [
     fieldName: "me",
     alias: null,
     arguments: null,
+    condition: null,
     selections: [
       {
         kind: "Scalar",
@@ -21,12 +22,14 @@ const readerAst: ReaderAst<Query__meNameSuccessor__param> = [
         fieldName: "successor",
         alias: null,
         arguments: null,
+        condition: null,
         selections: [
           {
             kind: "Linked",
             fieldName: "successor",
             alias: null,
             arguments: null,
+            condition: null,
             selections: [
               {
                 kind: "Scalar",

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

@@ -6,6 +6,7 @@ const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 
 const queryText = 'query nodeField ($id: ID!) {\
   node____id___v_id: node(id: $id) {\
+    __typename,\
     id,\
   },\
 }';
@@ -20,7 +21,13 @@ const normalizationAst: NormalizationAst = [
         { kind: "Variable", name: "id" },
       ],
     ],
+    concreteType: null,
     selections: [
+      {
+        kind: "Scalar",
+        fieldName: "__typename",
+        arguments: null,
+      },
       {
         kind: "Scalar",
         fieldName: "id",
@@ -34,8 +41,12 @@ const artifact: IsographEntrypoint<
   Query__nodeField__output_type
 > = {
   kind: "Entrypoint",
-  queryText,
-  normalizationAst,
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

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

@@ -1,6 +1,10 @@
+import type { Query__nodeField__parameters } from './parameters_type';
 
 export type Query__nodeField__param = {
-  node: ({
-    id: string,
-  } | null),
+  readonly data: {
+    readonly node: ({
+      readonly id: string,
+    } | null),
+  },
+  readonly parameters: Query__nodeField__parameters,
 };

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

@@ -0,0 +1,3 @@
+export type Query__nodeField__parameters = {
+  readonly id: string,
+};

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

@@ -14,6 +14,7 @@ const readerAst: ReaderAst<Query__nodeField__param> = [
         { kind: "Variable", name: "id" },
       ],
     ],
+    condition: null,
     selections: [
       {
         kind: "Scalar",

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

@@ -0,0 +1,67 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__subquery__param} from './param_type';
+import {Query__subquery__output_type} from './output_type';
+import readerResolver from './resolver_reader';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const queryText = 'query subquery ($id: ID!) {\
+  query {\
+    node____id___v_id: node(id: $id) {\
+      __typename,\
+      id,\
+    },\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "query",
+    arguments: null,
+    concreteType: "Query",
+    selections: [
+      {
+        kind: "Linked",
+        fieldName: "node",
+        arguments: [
+          [
+            "id",
+            { kind: "Variable", name: "id" },
+          ],
+        ],
+        concreteType: null,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "__typename",
+            arguments: null,
+          },
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            arguments: null,
+          },
+        ],
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__subquery__param,
+  Query__subquery__output_type
+> = {
+  kind: "Entrypoint",
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
+  readerWithRefetchQueries: {
+    kind: "ReaderWithRefetchQueries",
+    nestedRefetchQueries,
+    readerArtifact: readerResolver,
+  },
+};
+
+export default artifact;

package/src/tests/__isograph/Query/subquery/output_type.ts

@@ -0,0 +1,3 @@
+import type React from 'react';
+import { subquery as resolver } from '../../../normalizeData.test';
+export type Query__subquery__output_type = ReturnType<typeof resolver>;

package/src/tests/__isograph/Query/subquery/param_type.ts

@@ -0,0 +1,12 @@
+import type { Query__subquery__parameters } from './parameters_type';
+
+export type Query__subquery__param = {
+  readonly data: {
+    readonly query: {
+      readonly node: ({
+        readonly id: string,
+      } | null),
+    },
+  },
+  readonly parameters: Query__subquery__parameters,
+};

package/src/tests/__isograph/Query/subquery/parameters_type.ts

@@ -0,0 +1,3 @@
+export type Query__subquery__parameters = {
+  readonly id: string,
+};

package/src/tests/__isograph/Query/subquery/resolver_reader.ts

@@ -0,0 +1,47 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__subquery__param } from './param_type';
+import { Query__subquery__output_type } from './output_type';
+import { subquery as resolver } from '../../../normalizeData.test';
+
+const readerAst: ReaderAst<Query__subquery__param> = [
+  {
+    kind: "Linked",
+    fieldName: "query",
+    alias: null,
+    arguments: null,
+    condition: null,
+    selections: [
+      {
+        kind: "Linked",
+        fieldName: "node",
+        alias: null,
+        arguments: [
+          [
+            "id",
+            { kind: "Variable", name: "id" },
+          ],
+        ],
+        condition: null,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            alias: null,
+            arguments: null,
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__subquery__param,
+  Query__subquery__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  resolver,
+  readerAst,
+};
+
+export default artifact;

package/src/tests/__isograph/iso.ts

@@ -1,16 +1,18 @@
-import type {IsographEntrypoint} from '@isograph/react';
-import { Query__meNameSuccessor__param } from './Query/meNameSuccessor/param_type';
-import { Query__meName__param } from './Query/meName/param_type';
-import { Query__nodeField__param } from './Query/nodeField/param_type';
+import type { IsographEntrypoint } from '@isograph/react';
+import { type Query__meNameSuccessor__param } from './Query/meNameSuccessor/param_type';
+import { type Query__meName__param } from './Query/meName/param_type';
+import { type Query__nodeField__param } from './Query/nodeField/param_type';
+import { type Query__subquery__param } from './Query/subquery/param_type';
 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';
+import entrypoint_Query__subquery from '../__isograph/Query/subquery/entrypoint';
 
 // This is the type given to regular client fields.
 // This means that the type of the exported iso literal is exactly
 // the type of the passed-in function, which takes one parameter
 // of type TParam.
-type IdentityWithParam<TParam> = <TClientFieldReturn>(
+type IdentityWithParam<TParam extends object> = <TClientFieldReturn>(
   clientField: (param: TParam) => TClientFieldReturn
 ) => (param: TParam) => TClientFieldReturn;
 
@@ -21,7 +23,10 @@ type IdentityWithParam<TParam> = <TClientFieldReturn>(
 //
 // TComponentProps becomes the types of the props you must pass
 // whenever the @component field is rendered.
-type IdentityWithParamComponent<TParam> = <TClientFieldReturn, TComponentProps = Record<string, never>>(
+type IdentityWithParamComponent<TParam extends object> = <
+  TClientFieldReturn,
+  TComponentProps = Record<PropertyKey, never>,
+>(
   clientComponentField: (data: TParam, componentProps: TComponentProps) => TClientFieldReturn
 ) => (data: TParam, componentProps: TComponentProps) => TClientFieldReturn;
 
@@ -63,6 +68,10 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'field Query.nodeField', T>
 ): IdentityWithParam<Query__nodeField__param>;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.subquery', T>
+): IdentityWithParam<Query__subquery__param>;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.meNameSuccessor', T>
 ): typeof entrypoint_Query__meNameSuccessor;
@@ -75,14 +84,16 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.nodeField', T>
 ): typeof entrypoint_Query__nodeField;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.subquery', T>
+): typeof entrypoint_Query__subquery;
+
 export function iso(_isographLiteralText: string):
   | IdentityWithParam<any>
   | IdentityWithParamComponent<any>
   | IsographEntrypoint<any, any>
 {
-  return function identity<TClientFieldReturn>(
-    clientFieldOrEntrypoint: (param: any) => TClientFieldReturn,
-  ): (param: any) => TClientFieldReturn {
-    return clientFieldOrEntrypoint;
-  };
+  throw new Error('iso: Unexpected invocation at runtime. Either the Babel transform ' +
+      'was not set up, or it failed to identify this call site. Make sure it ' +
+      'is being used verbatim as `iso`.');
 }

package/src/tests/garbageCollection.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from 'vitest';
 import {
   ROOT_ID,
   createIsographEnvironment,
+  type IsographStore,
 } from '../core/IsographEnvironment';
 import {
   garbageCollectEnvironment,
@@ -10,32 +11,37 @@ import {
 import { iso } from './__isograph/iso';
 import { nodeFieldRetainedQuery } from './nodeQuery';
 
-const getDefaultStore = () => ({
-  [ROOT_ID]: {
-    me: { __link: '0' },
-    you: { __link: '1' },
-    node____id___0: {
-      __link: '0',
+const getDefaultStore = (): IsographStore => ({
+  Query: {
+    [ROOT_ID]: {
+      me: { __link: '0', __typename: 'Economist' },
+      you: { __link: '1', __typename: 'Economist' },
+      node____id___0: {
+        __link: '0',
+        __typename: 'Economist',
+      },
     },
   },
-  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' },
+  Economist: {
+    0: {
+      __typename: 'Economist',
+      id: '0',
+      name: 'Jeremy Bentham',
+      successor: { __link: '1', __typename: 'Economist' },
+    },
+    1: {
+      __typename: 'Economist',
+      id: '1',
+      name: 'John Stuart Mill',
+      predecessor: { __link: '0', __typename: 'Economist' },
+      successor: { __link: '2', __typename: 'Economist' },
+    },
+    2: {
+      __typename: 'Economist',
+      id: '2',
+      name: 'Henry Sidgwick',
+      predecessor: { __link: '1', __typename: 'Economist' },
+    },
   },
 });
 
@@ -46,12 +52,12 @@ export const meNameField = iso(`
     }
   }
 `)(() => {});
-import meNameEntrypoint from './__isograph/Query/meName/entrypoint';
 import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
-iso(`entrypoint Query.meName`);
+const meNameEntrypoint = iso(`entrypoint Query.meName`);
 const meNameRetainedQuery = {
-  normalizationAst: meNameEntrypoint.normalizationAst,
+  normalizationAst: meNameEntrypoint.networkRequestInfo.normalizationAst,
   variables: {},
+  root: { __link: ROOT_ID, __typename: 'Query' },
 };
 
 describe('garbage collection', () => {
@@ -63,13 +69,13 @@ describe('garbage collection', () => {
       null as any,
     );
 
-    expect(store[1]).not.toBe(undefined);
+    expect(store.Economist?.[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);
+    expect(store.Economist?.[1]).toBe(undefined);
   });
 
   test('Referenced records should not be garbage collected', () => {
@@ -80,13 +86,13 @@ describe('garbage collection', () => {
       null as any,
     );
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[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);
+    expect(store.Economist?.[0]).not.toBe(undefined);
   });
 
   test('Referenced records should not be garbage collected, and this should work with variables', () => {
@@ -97,12 +103,12 @@ describe('garbage collection', () => {
       null as any,
     );
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
 
     retainQuery(environment, nodeFieldRetainedQuery);
     garbageCollectEnvironment(environment);
 
-    expect(store[0]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
   });
 
   test('Referenced records should not be garbage collected, and this should work through multiple levels', () => {
@@ -116,12 +122,12 @@ describe('garbage collection', () => {
     retainQuery(environment, meNameSuccessorRetainedQuery);
     garbageCollectEnvironment(environment);
 
-    expect(store[0]).not.toBe(undefined);
-    expect(store[1]).not.toBe(undefined);
-    expect(store[2]).not.toBe(undefined);
+    expect(store.Economist?.[0]).not.toBe(undefined);
+    expect(store.Economist?.[1]).not.toBe(undefined);
+    expect(store.Economist?.[2]).not.toBe(undefined);
   });
 
-  test('ROOT_ID should not be garbage collected, even if there are no retained queries', () => {
+  test('ROOT_ID should be garbage collected, if there are no retained queries', () => {
     const store = getDefaultStore();
     const environment = createIsographEnvironment(
       store,
@@ -130,7 +136,7 @@ describe('garbage collection', () => {
     );
     garbageCollectEnvironment(environment);
 
-    expect(store[ROOT_ID]).not.toBe(undefined);
-    expect(store[0]).toBe(undefined);
+    expect(store.Query?.[ROOT_ID]).toBe(undefined);
+    expect(store.Economist?.[0]).toBe(undefined);
   });
 });

package/src/tests/meNameSuccessor.ts

@@ -1,3 +1,4 @@
+import { ROOT_ID } from '../core/IsographEnvironment';
 import { iso } from './__isograph/iso';
 
 export const meNameField = iso(`
@@ -12,9 +13,13 @@ export const meNameField = iso(`
     }
   }
 `)(() => {});
-import meNameSuccessorEntrypoint from './__isograph/Query/meNameSuccessor/entrypoint';
-iso(`entrypoint Query.meNameSuccessor`);
+const meNameSuccessorEntrypoint = iso(`entrypoint Query.meNameSuccessor`);
 export const meNameSuccessorRetainedQuery = {
-  normalizationAst: meNameSuccessorEntrypoint.normalizationAst,
+  normalizationAst:
+    meNameSuccessorEntrypoint.networkRequestInfo.normalizationAst,
   variables: {},
+  root: {
+    __link: ROOT_ID,
+    __typename: 'Query',
+  },
 };

package/src/tests/nodeQuery.ts

@@ -1,3 +1,5 @@
+import { RetainedQuery } from '../core/garbageCollection';
+import { ROOT_ID } from '../core/IsographEnvironment';
 import { iso } from './__isograph/iso';
 
 // TODO investigate why this can't be in garbageCollection.test.ts without
@@ -9,9 +11,9 @@ export const nodeField = iso(`
     }
   }
 `)(() => {});
-import nodeFieldEntrypoint from './__isograph/Query/nodeField/entrypoint';
-iso(`entrypoint Query.nodeField`);
-export const nodeFieldRetainedQuery = {
-  normalizationAst: nodeFieldEntrypoint.normalizationAst,
+const nodeFieldEntrypoint = iso(`entrypoint Query.nodeField`);
+export const nodeFieldRetainedQuery: RetainedQuery = {
+  normalizationAst: nodeFieldEntrypoint.networkRequestInfo.normalizationAst,
   variables: { id: 0 },
+  root: { __link: ROOT_ID, __typename: 'Query' },
 };