@data-client/core 0.9.7 → 0.11.0

package/src/controller/Controller.ts

@@ -1,24 +1,25 @@
 import type {
   ErrorTypes,
   SnapshotInterface,
-  DenormalizeCache,
   Schema,
   Denormalize,
+  Queryable,
+  SchemaArgs,
 } from '@data-client/normalizr';
 import {
-  WeakEntityMap,
   ExpiryStatus,
   EndpointInterface,
   FetchFunction,
   ResolveType,
   DenormalizeNullable,
-  Path,
-  denormalizeCached,
+  EntityPath,
+  MemoCache,
   isEntity,
   denormalize,
+  validateQueryKey,
 } from '@data-client/normalizr';
-import { inferResults, validateInference } from '@data-client/normalizr';
 
+import AbortOptimistic from './AbortOptimistic.js';
 import createExpireAll from './createExpireAll.js';
 import createFetch from './createFetch.js';
 import createInvalidate from './createInvalidate.js';
@@ -41,7 +42,7 @@ export type DataClientDispatch = (value: ActionTypes) => Promise<void>;
 interface ConstructorProps<D extends GenericDispatch = DataClientDispatch> {
   dispatch?: D;
   getState?: () => State<unknown>;
-  globalCache?: DenormalizeCache;
+  memo?: Pick<MemoCache, 'denormalize' | 'query' | 'buildQueryKey'>;
 }
 
 const unsetDispatch = (action: unknown): Promise<void> => {
@@ -77,19 +78,22 @@ export default class Controller<
    * @see https://dataclient.io/docs/api/Controller#getState
    */
   declare readonly getState: () => State<unknown>;
-  declare readonly globalCache: DenormalizeCache;
+  /**
+   * Singleton to maintain referential equality between calls
+   */
+  declare readonly memo: Pick<
+    MemoCache,
+    'denormalize' | 'query' | 'buildQueryKey'
+  >;
 
   constructor({
     dispatch = unsetDispatch as any,
     getState = unsetState,
-    globalCache = {
-      entities: {},
-      results: {},
-    },
+    memo = new MemoCache(),
   }: ConstructorProps<D> = {}) {
     this.dispatch = dispatch;
     this.getState = getState;
-    this.globalCache = globalCache;
+    this.memo = memo;
   }
 
   /*************** Action Dispatchers ***************/
@@ -103,9 +107,8 @@ export default class Controller<
   >(
     endpoint: E,
     ...args: readonly [...Parameters<E>]
-  ): E['schema'] extends undefined | null
-    ? ReturnType<E>
-    : Promise<Denormalize<E['schema']>> => {
+  ): E['schema'] extends undefined | null ? ReturnType<E>
+  : Promise<Denormalize<E['schema']>> => {
     const action = createFetch(endpoint, {
       args,
     });
@@ -128,9 +131,8 @@ export default class Controller<
   >(
     endpoint: E,
     ...args: readonly [...Parameters<E>]
-  ): E['schema'] extends undefined | null
-    ? ReturnType<E> | ResolveType<E>
-    : Promise<Denormalize<E['schema']>> | Denormalize<E['schema']> => {
+  ): E['schema'] extends undefined | null ? ReturnType<E> | ResolveType<E>
+  : Promise<Denormalize<E['schema']>> | Denormalize<E['schema']> => {
     const { data, expiresAt, expiryStatus } = this.getResponse(
       endpoint,
       ...args,
@@ -149,13 +151,13 @@ export default class Controller<
     endpoint: E,
     ...args: readonly [...Parameters<E>] | readonly [null]
   ): Promise<void> =>
-    args[0] !== null
-      ? this.dispatch(
-          createInvalidate(endpoint, {
-            args: args as readonly [...Parameters<E>],
-          }),
-        )
-      : Promise.resolve();
+    args[0] !== null ?
+      this.dispatch(
+        createInvalidate(endpoint, {
+          args: args as readonly [...Parameters<E>],
+        }),
+      )
+    : Promise.resolve();
 
   /**
    * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
@@ -241,7 +243,7 @@ export default class Controller<
           args: readonly [...Parameters<E>];
           response: any;
           fetchedAt: number;
-          error?: false;
+          error?: false | undefined;
         },
   ): Promise<void> => {
     return this.dispatch(createSet(endpoint, meta as any));
@@ -261,13 +263,13 @@ export default class Controller<
     endpoint: E,
     ...args: readonly [...Parameters<E>] | readonly [null]
   ): Promise<void> =>
-    args[0] !== null
-      ? this.dispatch(
-          createSubscription(endpoint, {
-            args: args as readonly [...Parameters<E>],
-          }),
-        )
-      : Promise.resolve();
+    args[0] !== null ?
+      this.dispatch(
+        createSubscription(endpoint, {
+          args: args as readonly [...Parameters<E>],
+        }),
+      )
+    : Promise.resolve();
 
   /**
    * Marks completion of subscription to a given Endpoint.
@@ -283,13 +285,13 @@ export default class Controller<
     endpoint: E,
     ...args: readonly [...Parameters<E>] | readonly [null]
   ): Promise<void> =>
-    args[0] !== null
-      ? this.dispatch(
-          createUnsubscription(endpoint, {
-            args: args as readonly [...Parameters<E>],
-          }),
-        )
-      : Promise.resolve();
+    args[0] !== null ?
+      this.dispatch(
+        createUnsubscription(endpoint, {
+          args: args as readonly [...Parameters<E>],
+        }),
+      )
+    : Promise.resolve();
 
   /*************** More ***************/
 
@@ -326,9 +328,9 @@ export default class Controller<
     const key = endpoint.key(...args);
 
     const meta = selectMeta(state, key);
-    const results = state.results[key];
+    const error = state.endpoints[key];
 
-    if (results !== undefined && meta?.errorPolicy === 'soft') return;
+    if (error !== undefined && meta?.errorPolicy === 'soft') return;
 
     return meta?.error as any;
   };
@@ -337,106 +339,183 @@ export default class Controller<
    * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
    * @see https://dataclient.io/docs/api/Controller#getResponse
    */
-  getResponse = <
+  getResponse<E extends EndpointInterface>(
+    endpoint: E,
+    ...rest: readonly [null, State<unknown>]
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  };
+
+  getResponse<E extends EndpointInterface>(
+    endpoint: E,
+    ...rest: readonly [...Parameters<E>, State<unknown>]
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  };
+
+  getResponse<
     E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
-    Args extends readonly [...Parameters<E['key']>] | readonly [null],
   >(
     endpoint: E,
-    ...rest: [...Args, State<unknown>]
+    ...rest: readonly [
+      ...(readonly [...Parameters<E['key']>] | readonly [null]),
+      State<unknown>,
+    ]
   ): {
     data: DenormalizeNullable<E['schema']>;
     expiryStatus: ExpiryStatus;
     expiresAt: number;
-  } => {
+  };
+
+  getResponse(
+    endpoint: EndpointInterface,
+    ...rest: readonly [...unknown[], State<unknown>]
+  ): {
+    data: unknown;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  } {
     const state = rest[rest.length - 1] as State<unknown>;
     // this is typescript generics breaking
     const args: any = rest
       .slice(0, rest.length - 1)
-      .map(ensurePojo) as Parameters<E['key']>;
+      // handle FormData
+      .map(ensurePojo);
     const isActive = args.length !== 1 || args[0] !== null;
     const key = isActive ? endpoint.key(...args) : '';
-    const cacheResults = isActive ? state.results[key] : undefined;
+    const cacheEndpoints = isActive ? state.endpoints[key] : undefined;
     const schema = endpoint.schema;
     const meta = selectMeta(state, key);
     let expiresAt = meta?.expiresAt;
-
-    let invalidResults = false;
-    let results;
-    if (cacheResults === undefined && endpoint.schema !== undefined) {
-      results = inferResults(
-        endpoint.schema,
-        args,
-        state.indexes,
-        state.entities,
-      );
-      invalidResults = !validateInference(results);
-      if (!expiresAt && invalidResults) expiresAt = 1;
-    } else {
-      results = cacheResults;
-    }
+    // if we have no endpoint entry, and our endpoint has a schema - try querying the store
+    const shouldQuery = cacheEndpoints === undefined && schema !== undefined;
+
+    const input =
+      shouldQuery ?
+        // nothing in endpoints cache, so try querying if we have a schema to do so
+        this.memo.buildQueryKey(
+          key,
+          schema,
+          args,
+          state.entities as any,
+          state.indexes,
+        )
+      : cacheEndpoints;
 
     if (!isActive) {
+      // when not active simply return the query input without denormalizing
       return {
-        data: results as any,
+        data: input as any,
         expiryStatus: ExpiryStatus.Valid,
         expiresAt: Infinity,
       };
     }
 
-    if (!endpoint.schema || !schemaHasEntity(endpoint.schema)) {
+    let isInvalid = false;
+    if (shouldQuery) {
+      isInvalid = !validateQueryKey(input);
+    } else if (!schema || !schemaHasEntity(schema)) {
       return {
-        data: results,
-        expiryStatus: meta?.invalidated
-          ? ExpiryStatus.Invalid
-          : cacheResults && !endpoint.invalidIfStale
-          ? ExpiryStatus.Valid
+        data: cacheEndpoints,
+        expiryStatus:
+          meta?.invalidated ? ExpiryStatus.Invalid
+          : cacheEndpoints && !endpoint.invalidIfStale ? ExpiryStatus.Valid
           : ExpiryStatus.InvalidIfStale,
         expiresAt: expiresAt || 0,
-      } as {
-        data: DenormalizeNullable<E['schema']>;
-        expiryStatus: ExpiryStatus;
-        expiresAt: number;
       };
     }
 
-    if (!this.globalCache.results[key])
-      this.globalCache.results[key] = new WeakEntityMap();
-
     // second argument is false if any entities are missing
     // eslint-disable-next-line prefer-const
-    const { data, paths } = denormalizeCached(
-      results,
+    const { data, paths } = this.memo.denormalize(
+      input,
       schema,
       state.entities,
-      this.globalCache.entities,
-      this.globalCache.results[key],
       args,
-    ) as { data: DenormalizeNullable<E['schema']>; paths: Path[] };
+    ) as { data: any; paths: EntityPath[] };
+
+    // note: isInvalid can only be true if shouldQuery is true
+    if (!expiresAt && isInvalid) expiresAt = 1;
+
+    return this.getSchemaResponse(
+      data,
+      paths,
+      state.entityMeta,
+      expiresAt,
+      endpoint.invalidIfStale || isInvalid,
+      meta,
+    );
+  }
+
+  /**
+   * Queries the store for a Querable schema
+   * @see https://dataclient.io/docs/api/Controller#get
+   */
+  get<S extends Queryable>(
+    schema: S,
+    ...rest: readonly [
+      ...SchemaArgs<S>,
+      Pick<State<unknown>, 'entities' | 'entityMeta'>,
+    ]
+  ): DenormalizeNullable<S> | undefined {
+    const state = rest[rest.length - 1] as State<any>;
+    // this is typescript generics breaking
+    const args: any = rest
+      .slice(0, rest.length - 1)
+      .map(ensurePojo) as SchemaArgs<S>;
+
+    // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
+    const key = JSON.stringify(args);
+
+    return this.memo.query(
+      key,
+      schema,
+      args,
+      state.entities as any,
+      state.indexes,
+    );
+  }
+
+  private getSchemaResponse<T>(
+    data: T,
+    paths: EntityPath[],
+    entityMeta: State<unknown>['entityMeta'],
+    expiresAt: number,
+    invalidIfStale: boolean,
+    meta: { error?: unknown; invalidated?: unknown } = {},
+  ): {
+    data: T;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  } {
     const invalidDenormalize = typeof data === 'symbol';
 
     // fallback to entity expiry time
     if (!expiresAt) {
-      expiresAt = entityExpiresAt(paths, state.entityMeta);
+      expiresAt = entityExpiresAt(paths, entityMeta);
     }
 
     // https://dataclient.io/docs/concepts/expiry-policy#expiry-status
     // we don't track the difference between stale or fresh because that is tied to triggering
     // conditions
     const expiryStatus =
-      meta?.invalidated || (invalidDenormalize && !meta?.error)
-        ? ExpiryStatus.Invalid
-        : invalidDenormalize || endpoint.invalidIfStale || invalidResults
-        ? ExpiryStatus.InvalidIfStale
-        : ExpiryStatus.Valid;
+      meta?.invalidated || (invalidDenormalize && !meta?.error) ?
+        ExpiryStatus.Invalid
+      : invalidDenormalize || invalidIfStale ? ExpiryStatus.InvalidIfStale
+      : ExpiryStatus.Valid;
 
     return { data, expiryStatus, expiresAt };
-  };
+  }
 }
 
 // benchmark: https://www.measurethat.net/Benchmarks/Show/24691/0/min-reducer-vs-imperative-with-paths
 // earliest expiry dictates age
 function entityExpiresAt(
-  paths: Path[],
+  paths: EntityPath[],
   entityMeta: {
     readonly [entityKey: string]: {
       readonly [pk: string]: {
@@ -458,7 +537,7 @@ function entityExpiresAt(
 
 /** Determine whether the schema has any entities.
  *
- * Without entities, denormalization is not needed, and results should not be inferred.
+ * Without entities, denormalization is not needed, and results should not be queried.
  */
 function schemaHasEntity(schema: Schema): boolean {
   if (isEntity(schema)) return true;
@@ -481,6 +560,7 @@ class Snapshot<T = unknown> implements SnapshotInterface {
   private state: State<T>;
   private controller: Controller;
   readonly fetchedAt: number;
+  readonly abort = new AbortOptimistic();
 
   constructor(controller: Controller, state: State<T>, fetchedAt = 0) {
     this.state = state;
@@ -490,20 +570,48 @@ class Snapshot<T = unknown> implements SnapshotInterface {
 
   /*************** Data Access ***************/
   /** @see https://dataclient.io/docs/api/Snapshot#getResponse */
-  getResponse = <
+  getResponse<E extends EndpointInterface>(
+    endpoint: E,
+    ...args: readonly [null]
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  };
+
+  getResponse<E extends EndpointInterface>(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>]
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  };
+
+  getResponse<
     E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
-    Args extends readonly [...Parameters<E['key']>],
   >(
     endpoint: E,
-    ...args: Args
+    ...args: readonly [...Parameters<E['key']>] | readonly [null]
   ): {
     data: DenormalizeNullable<E['schema']>;
     expiryStatus: ExpiryStatus;
     expiresAt: number;
-  } => {
-    return this.controller.getResponse(endpoint, ...args, this.state);
   };
 
+  getResponse<
+    E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>,
+  >(
+    endpoint: E,
+    ...args: readonly [...Parameters<E['key']>] | readonly [null]
+  ): {
+    data: DenormalizeNullable<E['schema']>;
+    expiryStatus: ExpiryStatus;
+    expiresAt: number;
+  } {
+    return this.controller.getResponse(endpoint, ...args, this.state);
+  }
+
   /** @see https://dataclient.io/docs/api/Snapshot#getError */
   getError = <
     E extends Pick<EndpointInterface, 'key'>,
@@ -514,4 +622,15 @@ class Snapshot<T = unknown> implements SnapshotInterface {
   ): ErrorTypes | undefined => {
     return this.controller.getError(endpoint, ...args, this.state);
   };
+
+  /**
+   * Retrieved memoized value for any Querable schema
+   * @see https://dataclient.io/docs/api/Snapshot#get
+   */
+  get<S extends Queryable>(
+    schema: S,
+    ...args: SchemaArgs<S>
+  ): DenormalizeNullable<S> | undefined {
+    return this.controller.get(schema, ...args, this.state);
+  }
 }

package/src/controller/__tests__/Controller.ts

@@ -1,9 +1,7 @@
-import { Endpoint, Entity } from '@data-client/endpoint';
 import { normalize } from '@data-client/normalizr';
 import { CoolerArticleResource } from '__tests__/new';
 import { createEntityMeta } from '__tests__/utils';
 
-import { ExpiryStatus } from '../..';
 import { initialState } from '../../state/reducer/createReducer';
 import Controller from '../Controller';
 
@@ -45,7 +43,7 @@ describe('Controller', () => {
       const state = {
         ...initialState,
         entities,
-        results: {
+        endpoints: {
           [fetchKey]: result,
         },
         entityMeta: createEntityMeta(entities),
@@ -82,7 +80,7 @@ describe('Controller', () => {
       const state = {
         ...initialState,
         entities,
-        results: {
+        endpoints: {
           [fetchKey]: result,
         },
         entityMeta: createEntityMeta(entities),

package/src/controller/__tests__/__snapshots__/get.ts.snap

@@ -0,0 +1,120 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Controller.get() Query+All based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.get() Query+All based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() Query+All based on args 3`] = `
+[
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+  Tacos {
+    "id": "3",
+    "name": "thing3",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() Union based on args 1`] = `
+User {
+  "id": "1",
+  "type": "users",
+  "username": "bob",
+}
+`;
+
+exports[`Controller.get() Union based on args 2`] = `
+Group {
+  "groupname": "fast",
+  "id": "2",
+  "memberCount": 5,
+  "type": "groups",
+}
+`;
+
+exports[`Controller.get() query All should get all entities 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() query All should include new entities when added 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+  Tacos {
+    "id": "3",
+    "type": "extra",
+  },
+]
+`;
+
+exports[`Controller.get() query Collection based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.get() query Collection based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() query Entity based on index 1`] = `
+User {
+  "id": "1",
+  "username": "bob",
+}
+`;
+
+exports[`Controller.get() query Entity based on pk 1`] = `
+Tacos {
+  "id": "1",
+  "type": "foo",
+}
+`;