@isograph/react 0.1.1 → 0.3.0

package/src/react/useRerenderOnChange.ts

@@ -0,0 +1,38 @@
+import { useEffect } from 'react';
+import { subscribe } from '../core/cache';
+import { WithEncounteredRecords } from '../core/read';
+import { FragmentReference } from '../core/FragmentReference';
+import { useIsographEnvironment } from './IsographEnvironmentProvider';
+import type { ReaderAst } from '../core/reader';
+
+// TODO add unit tests for this. Add integration tests that test
+// behavior when the encounteredRecords underneath a fragment change.
+export function useRerenderOnChange<
+  TReadFromStore extends { parameters: object; data: object },
+>(
+  encounteredDataAndRecords: WithEncounteredRecords<TReadFromStore>,
+  fragmentReference: FragmentReference<any, any>,
+  setEncounteredDataAndRecords: (
+    data: WithEncounteredRecords<TReadFromStore>,
+  ) => void,
+  readerAst: ReaderAst<TReadFromStore>,
+) {
+  const environment = useIsographEnvironment();
+  useEffect(() => {
+    return subscribe(
+      environment,
+      encounteredDataAndRecords,
+      fragmentReference,
+      (newEncounteredDataAndRecords) => {
+        setEncounteredDataAndRecords(newEncounteredDataAndRecords);
+      },
+      readerAst,
+    );
+    // Note: this is an empty array on purpose:
+    // - the fragment reference is stable for the life of the component
+    // - ownership of encounteredDataAndRecords is transferred into the
+    //   environment
+    // - though maybe we need to include setEncounteredDataAndRecords in
+    //   the dependency array
+  }, []);
+}

package/src/react/useResult.ts

@@ -0,0 +1,73 @@
+import { useIsographEnvironment } from '../react/IsographEnvironmentProvider';
+import { FragmentReference } from '../core/FragmentReference';
+import { getOrCreateCachedComponent } from '../core/componentCache';
+import { useReadAndSubscribe } from './useReadAndSubscribe';
+import {
+  getNetworkRequestOptionsWithDefaults,
+  NetworkRequestReaderOptions,
+} from '../core/read';
+import {
+  getPromiseState,
+  PromiseWrapper,
+  readPromise,
+} from '../core/PromiseWrapper';
+
+export function useResult<
+  TReadFromStore extends { parameters: object; data: object },
+  TClientFieldValue,
+>(
+  fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>,
+  partialNetworkRequestOptions?: Partial<NetworkRequestReaderOptions> | void,
+): TClientFieldValue {
+  const environment = useIsographEnvironment();
+  const networkRequestOptions = getNetworkRequestOptionsWithDefaults(
+    partialNetworkRequestOptions,
+  );
+
+  maybeUnwrapNetworkRequest(
+    fragmentReference.networkRequest,
+    networkRequestOptions,
+  );
+  const readerWithRefetchQueries = readPromise(
+    fragmentReference.readerWithRefetchQueries,
+  );
+
+  switch (readerWithRefetchQueries.readerArtifact.kind) {
+    case 'ComponentReaderArtifact': {
+      // @ts-expect-error
+      return getOrCreateCachedComponent(
+        environment,
+        readerWithRefetchQueries.readerArtifact.componentName,
+        fragmentReference,
+        networkRequestOptions,
+      );
+    }
+    case 'EagerReaderArtifact': {
+      const data = useReadAndSubscribe(
+        fragmentReference,
+        networkRequestOptions,
+        readerWithRefetchQueries.readerArtifact.readerAst,
+      );
+      const param = {
+        data: data,
+        parameters: fragmentReference.variables,
+      };
+      return readerWithRefetchQueries.readerArtifact.resolver(param);
+    }
+  }
+}
+
+export function maybeUnwrapNetworkRequest(
+  networkRequest: PromiseWrapper<void, any>,
+  networkRequestOptions: NetworkRequestReaderOptions,
+) {
+  const state = getPromiseState(networkRequest);
+  if (state.kind === 'Err' && networkRequestOptions.throwOnNetworkError) {
+    throw state.error;
+  } else if (
+    state.kind === 'Pending' &&
+    networkRequestOptions.suspendIfInFlight
+  ) {
+    throw state.promise;
+  }
+}

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

@@ -0,0 +1,52 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__meName__param} from './param_type';
+import {Query__meName__output_type} from './output_type';
+import readerResolver from './resolver_reader';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const queryText = 'query meName  {\
+  me {\
+    id,\
+    name,\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    arguments: null,
+    concreteType: "Economist",
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        arguments: null,
+      },
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        arguments: null,
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__meName__param,
+  Query__meName__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/meName/output_type.ts

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

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

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

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

@@ -0,0 +1,33 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__meName__param } from './param_type';
+import { Query__meName__output_type } from './output_type';
+import { meNameField as resolver } from '../../../garbageCollection.test';
+
+const readerAst: ReaderAst<Query__meName__param> = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    alias: null,
+    arguments: null,
+    condition: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        alias: null,
+        arguments: null,
+      },
+    ],
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__meName__param,
+  Query__meName__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  resolver,
+  readerAst,
+};
+
+export default artifact;

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

@@ -0,0 +1,90 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__meNameSuccessor__param} from './param_type';
+import {Query__meNameSuccessor__output_type} from './output_type';
+import readerResolver from './resolver_reader';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const queryText = 'query meNameSuccessor  {\
+  me {\
+    id,\
+    name,\
+    successor {\
+      id,\
+      successor {\
+        id,\
+        name,\
+      },\
+    },\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    arguments: null,
+    concreteType: "Economist",
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        arguments: null,
+      },
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        arguments: null,
+      },
+      {
+        kind: "Linked",
+        fieldName: "successor",
+        arguments: null,
+        concreteType: "Economist",
+        selections: [
+          {
+            kind: "Scalar",
+            fieldName: "id",
+            arguments: null,
+          },
+          {
+            kind: "Linked",
+            fieldName: "successor",
+            arguments: null,
+            concreteType: "Economist",
+            selections: [
+              {
+                kind: "Scalar",
+                fieldName: "id",
+                arguments: null,
+              },
+              {
+                kind: "Scalar",
+                fieldName: "name",
+                arguments: null,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+];
+const artifact: IsographEntrypoint<
+  Query__meNameSuccessor__param,
+  Query__meNameSuccessor__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/meNameSuccessor/output_type.ts

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

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

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

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

@@ -0,0 +1,57 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__meNameSuccessor__param } from './param_type';
+import { Query__meNameSuccessor__output_type } from './output_type';
+import { meNameField as resolver } from '../../../meNameSuccessor';
+
+const readerAst: ReaderAst<Query__meNameSuccessor__param> = [
+  {
+    kind: "Linked",
+    fieldName: "me",
+    alias: null,
+    arguments: null,
+    condition: null,
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "name",
+        alias: null,
+        arguments: null,
+      },
+      {
+        kind: "Linked",
+        fieldName: "successor",
+        alias: null,
+        arguments: null,
+        condition: null,
+        selections: [
+          {
+            kind: "Linked",
+            fieldName: "successor",
+            alias: null,
+            arguments: null,
+            condition: null,
+            selections: [
+              {
+                kind: "Scalar",
+                fieldName: "name",
+                alias: null,
+                arguments: null,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+];
+
+const artifact: EagerReaderArtifact<
+  Query__meNameSuccessor__param,
+  Query__meNameSuccessor__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  resolver,
+  readerAst,
+};
+
+export default artifact;

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

@@ -0,0 +1,57 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryNormalizationArtifactWrapper} from '@isograph/react';
+import {Query__nodeField__param} from './param_type';
+import {Query__nodeField__output_type} from './output_type';
+import readerResolver from './resolver_reader';
+const nestedRefetchQueries: RefetchQueryNormalizationArtifactWrapper[] = [];
+
+const queryText = 'query nodeField ($id: ID!) {\
+  node____id___v_id: node(id: $id) {\
+    __typename,\
+    id,\
+  },\
+}';
+
+const normalizationAst: NormalizationAst = [
+  {
+    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__nodeField__param,
+  Query__nodeField__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/nodeField/output_type.ts

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

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

@@ -0,0 +1,10 @@
+import type { Query__nodeField__parameters } from './parameters_type';
+
+export type Query__nodeField__param = {
+  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

@@ -0,0 +1,38 @@
+import type { EagerReaderArtifact, ReaderAst } from '@isograph/react';
+import { Query__nodeField__param } from './param_type';
+import { Query__nodeField__output_type } from './output_type';
+import { nodeField as resolver } from '../../../nodeQuery';
+
+const readerAst: ReaderAst<Query__nodeField__param> = [
+  {
+    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__nodeField__param,
+  Query__nodeField__output_type
+> = {
+  kind: "EagerReaderArtifact",
+  resolver,
+  readerAst,
+};
+
+export default artifact;

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;