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

package/src/core/startUpdate.ts

@@ -1,28 +1,325 @@
+import {
+  callSubscriptions,
+  getParentRecordKey,
+  insertEmptySetIfMissing,
+  type EncounteredIds,
+} from './cache';
+import type { RefetchQueryNormalizationArtifactWrapper } from './entrypoint';
 import {
   stableIdForFragmentReference,
+  type ExtractParameters,
   type ExtractStartUpdate,
+  type ExtractUpdatableData,
   type FragmentReference,
   type UnknownTReadFromStore,
 } from './FragmentReference';
-import type { IsographEnvironment } from './IsographEnvironment';
+import {
+  assertLink,
+  type IsographEnvironment,
+  type Link,
+} from './IsographEnvironment';
+import { readPromise, type PromiseWrapper } from './PromiseWrapper';
+import {
+  readImperativelyLoadedField,
+  readLinkedFieldData,
+  readLoadablySelectedFieldData,
+  readResolverFieldData,
+  readScalarFieldData,
+  type NetworkRequestReaderOptions,
+  type ReadDataResultSuccess,
+} from './read';
+import type { ReaderAst } from './reader';
 
 export function getOrCreateCachedStartUpdate<
   TReadFromStore extends UnknownTReadFromStore,
 >(
   environment: IsographEnvironment,
-  fragmentReference: FragmentReference<TReadFromStore, any>,
+  fragmentReference: FragmentReference<TReadFromStore, unknown>,
   eagerResolverName: string,
+  networkRequestOptions: NetworkRequestReaderOptions,
 ): ExtractStartUpdate<TReadFromStore> {
   return (environment.eagerReaderCache[
     stableIdForFragmentReference(fragmentReference, eagerResolverName)
-  ] ??= createStartUpdate(environment, fragmentReference));
+  ] ??= createStartUpdate(
+    environment,
+    fragmentReference,
+    networkRequestOptions,
+  ));
 }
 
 export function createStartUpdate<TReadFromStore extends UnknownTReadFromStore>(
-  _environment: IsographEnvironment,
-  _fragmentReference: FragmentReference<TReadFromStore, any>,
+  environment: IsographEnvironment,
+  fragmentReference: FragmentReference<TReadFromStore, unknown>,
+  networkRequestOptions: NetworkRequestReaderOptions,
 ): ExtractStartUpdate<TReadFromStore> {
-  return (_updater) => {
-    // TODO start update
+  return (updater) => {
+    let mutableUpdatedIds: EncounteredIds = new Map();
+
+    let data = createUpdatableProxy(
+      environment,
+      fragmentReference,
+      networkRequestOptions,
+      mutableUpdatedIds,
+    );
+
+    try {
+      updater(data);
+    } catch (e) {
+      throw e;
+    } finally {
+      callSubscriptions(environment, mutableUpdatedIds);
+    }
+  };
+}
+
+export function createUpdatableProxy<
+  TReadFromStore extends UnknownTReadFromStore,
+>(
+  environment: IsographEnvironment,
+  fragmentReference: FragmentReference<TReadFromStore, unknown>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  mutableUpdatedIds: EncounteredIds,
+): ExtractUpdatableData<TReadFromStore> {
+  const readerWithRefetchQueries = readPromise(
+    fragmentReference.readerWithRefetchQueries,
+  );
+
+  return readUpdatableData(
+    environment,
+    readerWithRefetchQueries.readerArtifact.readerAst,
+    fragmentReference.root,
+    fragmentReference.variables ?? {},
+    readerWithRefetchQueries.nestedRefetchQueries,
+    fragmentReference.networkRequest,
+    networkRequestOptions,
+    {
+      lastInvalidated: 0,
+    },
+    mutableUpdatedIds,
+  ).data;
+}
+
+type MutableInvalidationState = {
+  lastInvalidated: number;
+};
+
+function defineCachedProperty<T>(
+  target: T,
+  property: PropertyKey,
+  mutableState: MutableInvalidationState,
+  get: () => any,
+  set?: (v: any) => void,
+) {
+  let value:
+    | { kind: 'Set'; value: T; validatedAt: number }
+    | {
+        kind: 'NotSet';
+      } = {
+    kind: 'NotSet',
+  };
+
+  Object.defineProperty(target, property, {
+    configurable: false,
+    enumerable: true,
+    get: () => {
+      if (
+        value.kind === 'NotSet' ||
+        value.validatedAt < mutableState.lastInvalidated
+      ) {
+        value = {
+          kind: 'Set',
+          value: get(),
+          validatedAt: mutableState.lastInvalidated,
+        };
+      }
+      return value.value;
+    },
+    ...(set && {
+      set: (newValue) => {
+        set(newValue);
+        mutableState.lastInvalidated++;
+      },
+    }),
+  });
+}
+
+function readUpdatableData<TReadFromStore extends UnknownTReadFromStore>(
+  environment: IsographEnvironment,
+  ast: ReaderAst<TReadFromStore>,
+  root: Link,
+  variables: ExtractParameters<TReadFromStore>,
+  nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[],
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+  mutableState: MutableInvalidationState,
+  mutableUpdatedIds: EncounteredIds,
+): ReadDataResultSuccess<ExtractUpdatableData<TReadFromStore>> {
+  let storeRecord = environment.store[root.__typename]?.[root.__link];
+  if (storeRecord == null) {
+    return {
+      kind: 'Success',
+      data: null as any,
+    };
+  }
+
+  let target: { [index: string]: any } = {};
+
+  for (const field of ast) {
+    switch (field.kind) {
+      case 'Scalar': {
+        const storeRecordName = getParentRecordKey(field, variables);
+
+        defineCachedProperty(
+          target,
+          field.alias ?? field.fieldName,
+          mutableState,
+          () => {
+            const data = readScalarFieldData(
+              field,
+              storeRecord,
+              root,
+              variables,
+            );
+            if (data.kind === 'MissingData') {
+              throw new Error(data.reason);
+            }
+            return data.data;
+          },
+          field.isUpdatable
+            ? (newValue) => {
+                storeRecord[storeRecordName] = newValue;
+                const updatedIds = insertEmptySetIfMissing(
+                  mutableUpdatedIds,
+                  root.__typename,
+                );
+                updatedIds.add(root.__link);
+              }
+            : undefined,
+        );
+        break;
+      }
+      case 'Linked': {
+        const storeRecordName = getParentRecordKey(field, variables);
+        defineCachedProperty(
+          target,
+          field.alias ?? field.fieldName,
+          mutableState,
+          () => {
+            const data = readLinkedFieldData(
+              environment,
+              field,
+              storeRecord,
+              root,
+              variables,
+              nestedRefetchQueries,
+              networkRequest,
+              networkRequestOptions,
+              (ast, root) =>
+                readUpdatableData(
+                  environment,
+                  ast,
+                  root,
+                  variables,
+                  nestedRefetchQueries,
+                  networkRequest,
+                  networkRequestOptions,
+                  mutableState,
+                  mutableUpdatedIds,
+                ),
+            );
+            if (data.kind === 'MissingData') {
+              throw new Error(data.reason);
+            }
+            return data.data;
+          },
+          'isUpdatable' in field && field.isUpdatable
+            ? (newValue) => {
+                if (Array.isArray(newValue)) {
+                  storeRecord[storeRecordName] = newValue.map((node) =>
+                    assertLink(node?.link),
+                  );
+                } else {
+                  storeRecord[storeRecordName] = assertLink(newValue?.link);
+                }
+                const updatedIds = insertEmptySetIfMissing(
+                  mutableUpdatedIds,
+                  root.__typename,
+                );
+                updatedIds.add(root.__link);
+              }
+            : undefined,
+        );
+        break;
+      }
+      case 'ImperativelyLoadedField': {
+        defineCachedProperty(target, field.alias, mutableState, () => {
+          const data = readImperativelyLoadedField(
+            environment,
+            field,
+            root,
+            variables,
+            nestedRefetchQueries,
+            networkRequest,
+            networkRequestOptions,
+            new Map(),
+          );
+          if (data.kind === 'MissingData') {
+            throw new Error(data.reason);
+          }
+          return data.data;
+        });
+        break;
+      }
+      case 'Resolver': {
+        defineCachedProperty(target, field.alias, mutableState, () => {
+          const data = readResolverFieldData(
+            environment,
+            field,
+            root,
+            variables,
+            nestedRefetchQueries,
+            networkRequest,
+            networkRequestOptions,
+            new Map(),
+          );
+          if (data.kind === 'MissingData') {
+            throw new Error(data.reason);
+          }
+          return data.data;
+        });
+        break;
+      }
+      case 'LoadablySelectedField': {
+        defineCachedProperty(target, field.alias, mutableState, () => {
+          const data = readLoadablySelectedFieldData(
+            environment,
+            field,
+            root,
+            variables,
+            networkRequest,
+            networkRequestOptions,
+            new Map(),
+          );
+          if (data.kind === 'MissingData') {
+            throw new Error(data.reason);
+          }
+          return data.data;
+        });
+        break;
+      }
+      case 'Link': {
+        target[field.alias] = root;
+        break;
+      }
+      default: {
+        field satisfies never;
+        throw new Error('Unexpected case.');
+      }
+    }
+  }
+
+  return {
+    kind: 'Success',
+    data: target as any,
   };
 }

package/src/index.ts

@@ -18,6 +18,7 @@ export {
   NOT_SET,
 } from './core/PromiseWrapper';
 export {
+  callSubscriptions,
   subscribe,
   normalizeData,
   type NetworkResponseObject,

package/src/loadable-hooks/useConnectionSpecPagination.ts

@@ -135,6 +135,7 @@ export function useConnectionSpecPagination<
                 environment,
                 fragmentReference,
                 readerWithRefetchQueries.readerArtifact.fieldName,
+                networkRequestOptions,
               ),
             }
           : undefined),

package/src/loadable-hooks/useSkipLimitPagination.ts

@@ -129,6 +129,7 @@ export function useSkipLimitPagination<
                 environment,
                 fragmentReference,
                 readerWithRefetchQueries.readerArtifact.kind,
+                networkRequestOptions,
               ),
             }
           : undefined),

package/src/react/useResult.ts

@@ -61,6 +61,7 @@ export function useResult<
                 environment,
                 fragmentReference,
                 readerWithRefetchQueries.readerArtifact.fieldName,
+                networkRequestOptions,
               ),
             }
           : undefined),

package/src/tests/__isograph/Node/asEconomist/resolver_reader.ts

@@ -0,0 +1,28 @@
+import type { EagerReaderArtifact, ReaderAst, Link } from '@isograph/react';
+
+const readerAst: ReaderAst<{ data: any, parameters: Record<PropertyKey, never> }> = [
+  {
+    kind: "Scalar",
+    fieldName: "__typename",
+    alias: null,
+    arguments: null,
+    isUpdatable: false,
+  },
+  {
+    kind: "Link",
+    alias: "link",
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  { data: any, parameters: Record<PropertyKey, never> },
+  Link | null
+> = {
+  kind: "EagerReaderArtifact",
+  fieldName: "Node.asEconomist",
+  resolver: ({ data }) => data.__typename === "Economist" ? data.link : null,
+  readerAst,
+  hasUpdatable: false,
+};
+
+export default artifact;

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

@@ -0,0 +1,31 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__linkedUpdate__param} from './param_type';
+import {Query__linkedUpdate__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__linkedUpdate__param,
+  Query__linkedUpdate__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/linkedUpdate/normalization_ast.ts

@@ -0,0 +1,95 @@
+import type {NormalizationAst} from '@isograph/react';
+const normalizationAst: NormalizationAst = {
+  kind: "NormalizationAst",
+  selections: [
+    {
+      kind: "Linked",
+      fieldName: "node",
+      arguments: [
+        [
+          "id",
+          { kind: "Literal", value: 0 },
+        ],
+      ],
+      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,
+            },
+          ],
+        },
+      ],
+    },
+    {
+      kind: "Linked",
+      fieldName: "node",
+      arguments: [
+        [
+          "id",
+          { kind: "Literal", value: 1 },
+        ],
+      ],
+      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/linkedUpdate/output_type.ts

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

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

@@ -0,0 +1,51 @@
+import type { Link } from '@isograph/react';
+import type { StartUpdate } from '@isograph/react';
+
+export type Query__linkedUpdate__param = {
+  readonly data: {
+    readonly node: ({
+      /**
+A client pointer for the Economist type.
+      */
+      readonly asEconomist: ({
+        readonly name: string,
+      } | null),
+    } | null),
+    readonly john_stuart_mill: ({
+      /**
+A store Link for the Node type.
+      */
+      readonly link: Link,
+      /**
+A client pointer for the Economist type.
+      */
+      readonly asEconomist: ({
+        readonly name: string,
+      } | null),
+    } | null),
+  },
+  readonly parameters: Record<PropertyKey, never>,
+  readonly startUpdate: StartUpdate<{
+    get node(): ({
+      /**
+A client pointer for the Economist type.
+      */
+      readonly asEconomist: ({
+        name: string,
+      } | null),
+    } | null),
+    set node(value: ({ link: Link } | null)),
+    readonly john_stuart_mill: ({
+      /**
+A store Link for the Node type.
+      */
+      readonly link: Link,
+      /**
+A client pointer for the Economist type.
+      */
+      readonly asEconomist: ({
+        readonly name: string,
+      } | null),
+    } | null),
+  }>,
+};

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

@@ -0,0 +1,20 @@
+export default 'query linkedUpdate {\
+  node____id___l_0: node(id: 0) {\
+    __typename,\
+    id,\
+    ... on Economist {\
+      __typename,\
+      id,\
+      name,\
+    },\
+  },\
+  node____id___l_1: node(id: 1) {\
+    __typename,\
+    id,\
+    ... on Economist {\
+      __typename,\
+      id,\
+      name,\
+    },\
+  },\
+}';

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

@@ -0,0 +1,93 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__linkedUpdate__param } from './param_type';
+import { Query__linkedUpdate__output_type } from './output_type';
+import { linkedUpdate as resolver } from '../../../startUpdate.test';
+import Node__asEconomist__resolver_reader from '../../Node/asEconomist/resolver_reader';
+
+const readerAst: ReaderAst<Query__linkedUpdate__param> = [
+  {
+    kind: "Linked",
+    fieldName: "node",
+    alias: null,
+    arguments: [
+      [
+        "id",
+        { kind: "Literal", value: 0 },
+      ],
+    ],
+    condition: null,
+    isUpdatable: true,
+    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,
+  },
+  {
+    kind: "Linked",
+    fieldName: "node",
+    alias: "john_stuart_mill",
+    arguments: [
+      [
+        "id",
+        { kind: "Literal", value: 1 },
+      ],
+    ],
+    condition: null,
+    isUpdatable: false,
+    selections: [
+      {
+        kind: "Link",
+        alias: "link",
+      },
+      {
+        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: false,
+          },
+        ],
+        refetchQueryIndex: null,
+      },
+    ],
+    refetchQueryIndex: null,
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__linkedUpdate__param,
+  Query__linkedUpdate__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  fieldName: "Query.linkedUpdate",
+  resolver,
+  readerAst,
+  hasUpdatable: true,
+};
+
+export default artifact;