@isograph/react 0.0.0-main-3779371d → 0.0.0-main-adc27d88

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

@@ -0,0 +1,42 @@
+import type {IsographEntrypoint, NormalizationAst, RefetchQueryArtifactWrapper} from '@isograph/react';
+import type {Query__nodeField__param, Query__nodeField__outputType} from './reader';
+import readerResolver from './reader';
+const nestedRefetchQueries: RefetchQueryArtifactWrapper[] = [];
+
+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__outputType
+> = {
+  kind: "Entrypoint",
+  queryText,
+  normalizationAst,
+  nestedRefetchQueries,
+  readerArtifact: readerResolver,
+};
+
+export default artifact;

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

@@ -0,0 +1,45 @@
+import type {ReaderArtifact, ReaderAst, ExtractSecondParam} from '@isograph/react';
+import { nodeField as resolver } from '../../../nodeQuery.ts';
+
+// the type, when read out (either via useLazyReference or via graph)
+export type Query__nodeField__outputType = ReturnType<typeof resolver>;
+
+const readerAst: ReaderAst<Query__nodeField__param> = [
+  {
+    kind: "Linked",
+    fieldName: "node",
+    alias: null,
+    arguments: [
+      [
+        "id",
+        { kind: "Variable", name: "id" },
+      ],
+    ],
+    selections: [
+      {
+        kind: "Scalar",
+        fieldName: "id",
+        alias: null,
+        arguments: null,
+      },
+    ],
+  },
+];
+
+export type Query__nodeField__param = {
+  node: ({
+    id: string,
+  } | null),
+};
+
+const artifact: ReaderArtifact<
+  Query__nodeField__param,
+  Query__nodeField__outputType
+> = {
+  kind: "ReaderArtifact",
+  resolver: resolver as any,
+  readerAst,
+  variant: { kind: "Eager" },
+};
+
+export default artifact;

package/src/tests/__isograph/iso.ts

@@ -0,0 +1,60 @@
+import type {IsographEntrypoint} from '@isograph/react';
+import { Query__meNameSuccessor__param } from './Query/meNameSuccessor/reader'
+import { Query__meName__param } from './Query/meName/reader'
+import { Query__nodeField__param } from './Query/nodeField/reader'
+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'
+
+type IdentityWithParam<TParam> = <TResolverReturn>(
+  x: (param: TParam) => TResolverReturn
+) => (param: TParam) => TResolverReturn;
+type IdentityWithParamComponent<TParam> = <TResolverReturn, TSecondParam = Record<string, never>>(
+  x: (data: TParam, secondParam: TSecondParam) => TResolverReturn
+) => (data: TParam, secondParam: TSecondParam) => TResolverReturn;
+
+type WhitespaceCharacter = ' ' | '\t' | '\n';
+type Whitespace<In> = In extends `${WhitespaceCharacter}${infer In}`
+  ? Whitespace<In>
+  : In;
+
+type MatchesWhitespaceAndString<
+  TString extends string,
+  T
+> = Whitespace<T> extends `${TString}${string}` ? T : never;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.meNameSuccessor', T>
+): IdentityWithParam<Query__meNameSuccessor__param>;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.meName', T>
+): IdentityWithParam<Query__meName__param>;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'field Query.nodeField', T>
+): IdentityWithParam<Query__nodeField__param>;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.meNameSuccessor', T>
+): typeof entrypoint_Query__meNameSuccessor;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.meName', T>
+): typeof entrypoint_Query__meName;
+
+export function iso<T>(
+  param: T & MatchesWhitespaceAndString<'entrypoint Query.nodeField', T>
+): typeof entrypoint_Query__nodeField;
+
+export function iso(_isographLiteralText: string):
+  | IdentityWithParam<any>
+  | IdentityWithParamComponent<any>
+  | IsographEntrypoint<any, any>
+{
+  return function identity<TResolverReturn>(
+    clientFieldOrEntrypoint: (param: any) => TResolverReturn,
+  ): (param: any) => TResolverReturn {
+    return clientFieldOrEntrypoint;
+  };
+}

package/src/tests/garbageCollection.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect } from 'vitest';
+import { ROOT_ID, createIsographEnvironment } from '../IsographEnvironment';
+import { garbageCollectEnvironment, retainQuery } from '../garbageCollection';
+import { iso } from './__isograph/iso';
+import { nodeFieldRetainedQuery } from './nodeQuery';
+
+const getDefaultStore = () => ({
+  [ROOT_ID]: {
+    me: { __link: '0' },
+    you: { __link: '1' },
+    node____id___0: {
+      __link: '0',
+    },
+  },
+  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' },
+  },
+});
+
+export const meNameField = iso(`
+  field Query.meName {
+    me {
+      name
+    }
+  }
+`)(() => {});
+import meNameEntrypoint from './__isograph/Query/meName/entrypoint';
+import { meNameSuccessorRetainedQuery } from './meNameSuccessor';
+iso(`entrypoint Query.meName`);
+const meNameRetainedQuery = {
+  normalizationAst: meNameEntrypoint.normalizationAst,
+  variables: {},
+};
+
+describe('garbage collection', () => {
+  test('Unreferenced records should be garbage collected', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[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);
+  });
+
+  test('Referenced records should not be garbage collected', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[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);
+  });
+
+  test('Referenced records should not be garbage collected, and this should work with variables', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    expect(store[0]).not.toBe(undefined);
+
+    retainQuery(environment, nodeFieldRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+  });
+
+  test('Referenced records should not be garbage collected, and this should work through multiple levels', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+
+    retainQuery(environment, meNameSuccessorRetainedQuery);
+    garbageCollectEnvironment(environment);
+
+    expect(store[0]).not.toBe(undefined);
+    expect(store[1]).not.toBe(undefined);
+    expect(store[2]).not.toBe(undefined);
+  });
+
+  test('ROOT_ID should not be garbage collected, even if there are no retained queries', () => {
+    const store = getDefaultStore();
+    const environment = createIsographEnvironment(
+      store,
+      null as any,
+      null as any,
+    );
+    garbageCollectEnvironment(environment);
+
+    expect(store[ROOT_ID]).not.toBe(undefined);
+    expect(store[0]).toBe(undefined);
+  });
+});

package/src/tests/isograph.config.json

@@ -0,0 +1,7 @@
+{
+  "project_root": ".",
+  "schema": "./schema.graphql",
+  "options": {
+    "on_invalid_id_type": "error"
+  }
+}

package/src/tests/meNameSuccessor.ts

@@ -0,0 +1,20 @@
+import { iso } from './__isograph/iso';
+
+export const meNameField = iso(`
+  field Query.meNameSuccessor {
+    me {
+      name
+      successor {
+        successor {
+          name
+        }
+      }
+    }
+  }
+`)(() => {});
+import meNameSuccessorEntrypoint from './__isograph/Query/meNameSuccessor/entrypoint';
+iso(`entrypoint Query.meNameSuccessor`);
+export const meNameSuccessorRetainedQuery = {
+  normalizationAst: meNameSuccessorEntrypoint.normalizationAst,
+  variables: {},
+};

package/src/tests/nodeQuery.ts

@@ -0,0 +1,17 @@
+import { iso } from './__isograph/iso';
+
+// TODO investigate why this can't be in garbageCollection.test.ts without
+// typescript incorrectly thinking it is referenced in its own initializer
+export const nodeField = iso(`
+  field Query.nodeField($id: ID!) {
+    node(id: $id) {
+      id
+    }
+  }
+`)(() => {});
+import nodeFieldEntrypoint from './__isograph/Query/nodeField/entrypoint';
+iso(`entrypoint Query.nodeField`);
+export const nodeFieldRetainedQuery = {
+  normalizationAst: nodeFieldEntrypoint.normalizationAst,
+  variables: { id: 0 },
+};

package/src/tests/schema.graphql

@@ -0,0 +1,16 @@
+type Query {
+  me: Economist!
+  you: Economist!
+  node(id: ID!): Node
+}
+
+type Economist implements Node {
+  id: ID!
+  name: String!
+  predecessor: Economist
+  successor: Economist
+}
+
+interface Node {
+  id: ID!
+}

package/src/tests/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "allowImportingTsExtensions": true,
+    "paths": {
+      "@isograph/react": ["../index.ts"],
+    },
+  },
+}

package/src/useRerenderWhenEncounteredRecordChanges.ts

@@ -0,0 +1,15 @@
+import { useEffect, useState } from 'react';
+import { DataId, IsographEnvironment } from './IsographEnvironment';
+import { subscribe } from './cache';
+
+export function useRerenderWhenEncounteredRecordChanges(
+  environment: IsographEnvironment,
+  encounteredRecords: Set<DataId>,
+) {
+  const [, setState] = useState<object | void>();
+  useEffect(() => {
+    return subscribe(environment, encounteredRecords, () => {
+      return setState({});
+    });
+  }, []);
+}

package/src/useResult.ts

@@ -1,20 +1,19 @@
-import { useEffect, useState } from 'react';
 import { useIsographEnvironment } from './IsographEnvironmentProvider';
-import { subscribe } from './cache';
 import { read } from './read';
 import { FragmentReference } from './FragmentReference';
+import { useRerenderWhenEncounteredRecordChanges } from './useRerenderWhenEncounteredRecordChanges';
 
 export function useResult<TReadFromStore extends Object, TClientFieldValue>(
   fragmentReference: FragmentReference<TReadFromStore, TClientFieldValue>,
 ): TClientFieldValue {
   const environment = useIsographEnvironment();
 
-  const [, setState] = useState<object | void>();
-  useEffect(() => {
-    return subscribe(environment, () => {
-      return setState({});
-    });
-  }, []);
+  const { item: data, encounteredRecords } = read(
+    environment,
+    fragmentReference,
+  );
 
-  return read(environment, fragmentReference);
+  useRerenderWhenEncounteredRecordChanges(environment, encounteredRecords);
+
+  return data;
 }

package/tsconfig.pkg.json

@@ -7,5 +7,6 @@
     "jsx": "react",
     "lib": ["es2017", "DOM"]
   },
-  "include": ["./**/*.ts", "./**/*.tsx"]
+  "include": ["./**/*.ts", "./**/*.tsx"],
+  "exclude": ["./src/tests/**/*"]
 }