@isograph/react 0.2.0 → 0.3.1

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

@@ -2,40 +2,22 @@ import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArti
 import {Query__nodeField__param} from './param_type';
 import {Query__nodeField__output_type} from './output_type';
 import readerResolver from './resolver_reader';
+import queryText from './query_text';
+import normalizationAst from './normalization_ast';
 const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
 
-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__output_type
+  Query__nodeField__output_type,
+  NormalizationAst
 > = {
   kind: "Entrypoint",
-  queryText,
-  normalizationAst,
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
   readerWithRefetchQueries: {
     kind: "ReaderWithRefetchQueries",
     nestedRefetchQueries,

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

@@ -0,0 +1,30 @@
+import type {NormalizationAst} from '@isograph/react';
+const normalizationAst: NormalizationAst = {
+  kind: "NormalizationAst",
+  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,
+        },
+      ],
+    },
+  ],
+};
+export default normalizationAst;

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/query_text.ts

@@ -0,0 +1,6 @@
+export default 'query nodeField ($id: ID!) {\
+  node____id___v_id: node(id: $id) {\
+    __typename,\
+    id,\
+  },\
+}';

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

@@ -14,12 +14,15 @@ const readerAst: ReaderAst<Query__nodeField__param> = [
         { kind: "Variable", name: "id" },
       ],
     ],
+    condition: null,
+    isUpdatable: false,
     selections: [
       {
         kind: "Scalar",
         fieldName: "id",
         alias: null,
         arguments: null,
+        isUpdatable: false,
       },
     ],
   },
@@ -30,8 +33,10 @@ const artifact: EagerReaderArtifact<
   Query__nodeField__output_type
 > = {
   kind: "EagerReaderArtifact",
+  fieldName: "Query.nodeField",
   resolver,
   readerAst,
+  hasUpdatable: false,
 };
 
 export default artifact;

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

@@ -0,0 +1,28 @@
+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';
+import queryText from './query_text';
+import normalizationAst from './normalization_ast';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const artifact: IsographEntrypoint<
+  Query__subquery__param,
+  Query__subquery__output_type,
+  NormalizationAst
+> = {
+  kind: "Entrypoint",
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    queryText,
+    normalizationAst,
+  },
+  concreteType: "Query",
+  readerWithRefetchQueries: {
+    kind: "ReaderWithRefetchQueries",
+    nestedRefetchQueries,
+    readerArtifact: readerResolver,
+  },
+};
+
+export default artifact;

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

@@ -0,0 +1,38 @@
+import type {NormalizationAst} from '@isograph/react';
+const normalizationAst: NormalizationAst = {
+  kind: "NormalizationAst",
+  selections: [
+    {
+      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,
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+export default normalizationAst;

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/query_text.ts

@@ -0,0 +1,8 @@
+export default 'query subquery ($id: ID!) {\
+  query {\
+    node____id___v_id: node(id: $id) {\
+      __typename,\
+      id,\
+    },\
+  },\
+}';

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

@@ -0,0 +1,52 @@
+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,
+    isUpdatable: false,
+    selections: [
+      {
+        kind: "Linked",
+        fieldName: "node",
+        alias: null,
+        arguments: [
+          [
+            "id",
+            { kind: "Variable", name: "id" },
+          ],
+        ],
+        condition: null,
+        isUpdatable: false,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            alias: null,
+            arguments: null,
+            isUpdatable: false,
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__subquery__param,
+  Query__subquery__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  fieldName: "Query.subquery",
+  resolver,
+  readerAst,
+  hasUpdatable: false,
+};
+
+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,17 @@ 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>
+  | IsographEntrypoint<any, 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`. If you cannot use the babel transform, ' + 
+      'set options.no_babel_transform to true in your Isograph config. ');
 }

package/src/tests/garbageCollection.test.ts

@@ -1,41 +1,48 @@
-import { describe, test, expect } from 'vitest';
-import {
-  ROOT_ID,
-  createIsographEnvironment,
-} from '../core/IsographEnvironment';
+import { describe, expect, test } from 'vitest';
 import {
   garbageCollectEnvironment,
   retainQuery,
 } from '../core/garbageCollection';
+import {
+  createIsographEnvironment,
+  ROOT_ID,
+  type IsographStore,
+} from '../core/IsographEnvironment';
 import { iso } from './__isograph/iso';
+import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
 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 +53,13 @@ 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.selections,
   variables: {},
+  root: { __link: ROOT_ID, __typename: 'Query' },
 };
 
 describe('garbage collection', () => {
@@ -63,13 +71,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 +88,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 +105,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 +124,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 +138,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.selections,
   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,10 @@ 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.selections,
   variables: { id: 0 },
+  root: { __link: ROOT_ID, __typename: 'Query' },
 };