@isograph/react 0.3.1 → 0.4.0

package/src/tests/__isograph/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "compilerOptions": {
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "jsx": "preserve",
+        "esModuleInterop": true
+    }
+}

package/src/tests/normalizeData.test.ts

@@ -40,7 +40,6 @@ describe('normalizeData', () => {
         query: { node____id___v_id: { __typename: 'Economist', id: '1' } },
       },
       { id: '1' },
-      entrypoint.readerWithRefetchQueries.nestedRefetchQueries,
       { __link: ROOT_ID, __typename: entrypoint.concreteType },
     );
 

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',
+          },
+        },
+      });
+    });
+  });
+});

package/.turbo/turbo-compile-typescript.log

@@ -1,4 +0,0 @@
-
-> @isograph/react@0.3.1 compile-typescript /Users/runner/work/isograph/isograph/libs/isograph-react
-> rm -rf dist/* && tsc -p tsconfig.pkg.json
-