@isograph/react 0.0.0-main-05f9fa46 → 0.0.0-main-0300c896

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

@@ -0,0 +1,31 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__startUpdate__param} from './param_type';
+import {Query__startUpdate__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__startUpdate__param,
+  Query__startUpdate__output_type,
+  NormalizationAst
+> = {
+  kind: "Entrypoint",
+  networkRequestInfo: {
+    kind: "NetworkRequestInfo",
+    operation: {
+      kind: "Operation",
+      text: queryText,
+    },
+    normalizationAst,
+  },
+  concreteType: "Query",
+  readerWithRefetchQueries: {
+    kind: "ReaderWithRefetchQueries",
+    nestedRefetchQueries,
+    readerArtifact: readerResolver,
+  },
+};
+
+export default artifact;

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

@@ -0,0 +1,51 @@
+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,
+        },
+        {
+          kind: "InlineFragment",
+          type: "Economist",
+          selections: [
+            {
+              kind: "Scalar",
+              fieldName: "__typename",
+              arguments: null,
+            },
+            {
+              kind: "Scalar",
+              fieldName: "id",
+              arguments: null,
+            },
+            {
+              kind: "Scalar",
+              fieldName: "name",
+              arguments: null,
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+export default normalizationAst;

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

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

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

@@ -0,0 +1,26 @@
+import type { StartUpdate } from '@isograph/react';
+import type { Query__startUpdate__parameters } from './parameters_type';
+
+export type Query__startUpdate__param = {
+  readonly data: {
+    readonly node: ({
+      /**
+A client pointer for the Economist type.
+      */
+      readonly asEconomist: ({
+        readonly name: string,
+      } | null),
+    } | null),
+  },
+  readonly parameters: Query__startUpdate__parameters,
+  readonly startUpdate: StartUpdate<{
+    readonly node: ({
+      /**
+A client pointer for the Economist type.
+      */
+      readonly asEconomist: ({
+        name: string,
+      } | null),
+    } | null),
+  }>,
+};

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

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

package/src/tests/__isograph/Query/startUpdate/query_text.ts

@@ -0,0 +1,11 @@
+export default 'query startUpdate($id: ID!) {\
+  node____id___v_id: node(id: $id) {\
+    __typename,\
+    id,\
+    ... on Economist {\
+      __typename,\
+      id,\
+      name,\
+    },\
+  },\
+}';

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

@@ -0,0 +1,55 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__startUpdate__param } from './param_type';
+import { Query__startUpdate__output_type } from './output_type';
+import { startUpdate as resolver } from '../../../startUpdate.test';
+import Node__asEconomist__resolver_reader from '../../Node/asEconomist/resolver_reader';
+
+const readerAst: ReaderAst<Query__startUpdate__param> = [
+  {
+    kind: "Linked",
+    fieldName: "node",
+    alias: null,
+    arguments: [
+      [
+        "id",
+        { kind: "Variable", name: "id" },
+      ],
+    ],
+    condition: null,
+    isUpdatable: false,
+    selections: [
+      {
+        kind: "Linked",
+        fieldName: "asEconomist",
+        alias: null,
+        arguments: null,
+        condition: Node__asEconomist__resolver_reader,
+        isUpdatable: false,
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "name",
+            alias: null,
+            arguments: null,
+            isUpdatable: true,
+          },
+        ],
+        refetchQueryIndex: null,
+      },
+    ],
+    refetchQueryIndex: null,
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__startUpdate__param,
+  Query__startUpdate__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  fieldName: "Query.startUpdate",
+  resolver,
+  readerAst,
+  hasUpdatable: true,
+};
+
+export default artifact;

package/src/tests/__isograph/iso.ts

@@ -1,11 +1,15 @@
 import type { IsographEntrypoint } from '@isograph/react';
+import { type Query__linkedUpdate__param } from './Query/linkedUpdate/param_type';
 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__startUpdate__param } from './Query/startUpdate/param_type';
 import { type Query__subquery__param } from './Query/subquery/param_type';
+import entrypoint_Query__linkedUpdate from '../__isograph/Query/linkedUpdate/entrypoint';
 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__startUpdate from '../__isograph/Query/startUpdate/entrypoint';
 import entrypoint_Query__subquery from '../__isograph/Query/subquery/entrypoint';
 
 // This is the type given to regular client fields.
@@ -56,6 +60,10 @@ type MatchesWhitespaceAndString<
   T
 > = Whitespace<T> extends `${TString}${string}` ? T : never;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.linkedUpdate', T>
+): IdentityWithParam<Query__linkedUpdate__param>;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'field Query.meNameSuccessor', T>
 ): IdentityWithParam<Query__meNameSuccessor__param>;
@@ -68,10 +76,18 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'field Query.nodeField', T>
 ): IdentityWithParam<Query__nodeField__param>;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.startUpdate', T>
+): IdentityWithParam<Query__startUpdate__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.linkedUpdate', T>
+): typeof entrypoint_Query__linkedUpdate;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.meNameSuccessor', T>
 ): typeof entrypoint_Query__meNameSuccessor;
@@ -84,6 +100,10 @@ export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.nodeField', T>
 ): typeof entrypoint_Query__nodeField;
 
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.startUpdate', T>
+): typeof entrypoint_Query__startUpdate;
+
 export function iso<T>(
   param: T & MatchesWhitespaceAndString<'entrypoint Query.subquery', T>
 ): typeof entrypoint_Query__subquery;

package/src/tests/startUpdate.test.ts

@@ -0,0 +1,205 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { getOrCreateCacheForArtifact } from '../core/cache';
+import type { ExtractUpdatableData } from '../core/FragmentReference';
+import {
+  createIsographEnvironment,
+  ROOT_ID,
+  type IsographStore,
+} from '../core/IsographEnvironment';
+import { createUpdatableProxy } from '../core/startUpdate';
+import { iso } from './__isograph/iso';
+import type { Query__linkedUpdate__param } from './__isograph/Query/linkedUpdate/param_type';
+import type { Query__startUpdate__param } from './__isograph/Query/startUpdate/param_type';
+
+const getDefaultStore = (): IsographStore => ({
+  Query: {
+    [ROOT_ID]: {
+      node____id___0: {
+        __link: '0',
+        __typename: 'Economist',
+      },
+      node____id___1: {
+        __link: '1',
+        __typename: 'Economist',
+      },
+    },
+  },
+  Economist: {
+    0: {
+      __typename: 'Economist',
+      id: '0',
+      name: 'Jeremy Bentham',
+    },
+    1: {
+      __typename: 'Economist',
+      id: '1',
+      name: 'John Stuart Mill',
+    },
+  },
+});
+
+export const startUpdate = iso(`
+  field Query.startUpdate($id: ID!) {
+    node(id: $id) {
+      asEconomist {
+        name @updatable
+      }
+    }
+  }  
+`)(() => {});
+
+export const linkedUpdate = iso(`
+  field Query.linkedUpdate {
+    node(id: 0) @updatable {
+      asEconomist {
+        name @updatable
+      }
+    }
+    john_stuart_mill: node(id: 1) {
+      link
+      asEconomist {
+        name
+      }
+    }
+  }  
+`)(() => {});
+
+describe('startUpdate', () => {
+  let environment: ReturnType<typeof createIsographEnvironment>;
+
+  beforeEach(() => {
+    const store = getDefaultStore();
+    const networkFunction = vi
+      .fn()
+      .mockRejectedValue(new Error('Fetch failed'));
+    environment = createIsographEnvironment(store, networkFunction);
+  });
+
+  describe('linked field', () => {
+    let data: ExtractUpdatableData<Query__linkedUpdate__param>;
+
+    beforeEach(() => {
+      const [_cacheItem, item, _disposeOfTemporaryRetain] =
+        getOrCreateCacheForArtifact(
+          environment,
+          iso(`entrypoint Query.linkedUpdate`),
+          {},
+        ).getOrPopulateAndTemporaryRetain();
+
+      data = createUpdatableProxy(
+        environment,
+        item,
+        {
+          suspendIfInFlight: true,
+          throwOnNetworkError: true,
+        },
+        new Map(),
+      );
+    });
+
+    test('updates updatable scalar nested in updatable object', () => {
+      data.node!.asEconomist!.name = 'Updated Jeremy Bentham';
+
+      expect(environment.store).toMatchObject({
+        Economist: {
+          '0': {
+            name: 'Updated Jeremy Bentham',
+          },
+        },
+      });
+    });
+
+    test('updates linked field in data', () => {
+      data.node = data.john_stuart_mill;
+
+      expect(data).toMatchObject({
+        node: {
+          asEconomist: {
+            name: 'John Stuart Mill',
+          },
+        },
+      });
+    });
+
+    test('updates scalar in old object after setting linked field', () => {
+      let jeremy = data.node;
+      data.node = data.john_stuart_mill;
+      jeremy!.asEconomist!.name = 'Updated Jeremy Bentham';
+
+      expect(environment.store).toMatchObject({
+        Economist: {
+          '0': {
+            name: 'Updated Jeremy Bentham',
+          },
+        },
+        Query: {
+          __ROOT: {
+            node____id___0: {
+              __link: '1',
+              __typename: 'Economist',
+            },
+          },
+        },
+      });
+    });
+  });
+
+  describe('scalar field', () => {
+    let data: ExtractUpdatableData<Query__startUpdate__param>;
+
+    beforeEach(() => {
+      const [_cacheItem, item, _disposeOfTemporaryRetain] =
+        getOrCreateCacheForArtifact(
+          environment,
+          iso(`entrypoint Query.startUpdate`),
+          {
+            id: '0',
+          },
+        ).getOrPopulateAndTemporaryRetain();
+
+      data = createUpdatableProxy(
+        environment,
+        item,
+        {
+          suspendIfInFlight: true,
+          throwOnNetworkError: true,
+        },
+        new Map(),
+      );
+    });
+
+    test('reads data', () => {
+      expect(data).toStrictEqual({
+        node: {
+          asEconomist: {
+            name: 'Jeremy Bentham',
+          },
+        },
+      });
+    });
+
+    test('updates scalar in cache', () => {
+      data.node!.asEconomist!.name = 'Foo';
+
+      expect(environment.store).toMatchObject({
+        Economist: {
+          0: {
+            name: 'Foo',
+          },
+        },
+      });
+    });
+
+    test('updates scalar in data', () => {
+      data.node!.asEconomist!.name = 'Foo';
+
+      expect(data).toStrictEqual({
+        node: {
+          asEconomist: {
+            name: 'Foo',
+          },
+        },
+      });
+    });
+  });
+});