@data-client/core 0.13.5 → 0.14.0

package/src/controller/{createFetch.ts → actions/createFetch.ts}

@@ -1,39 +1,35 @@
 import type { EndpointInterface, NI } from '@data-client/normalizr';
 
-import { EndpointUpdateFunction } from './types.js';
-import { FETCH_TYPE } from '../actionTypes.js';
-import type { FetchAction, FetchMeta } from '../types.js';
+import { FETCH_TYPE } from '../../actionTypes.js';
+import type { FetchAction, FetchMeta } from '../../types.js';
+import { EndpointUpdateFunction } from '../types.js';
 
 /**
  * Requesting a fetch to begin
  */
-export default function createFetch<
+export function createFetch<
   E extends EndpointInterface & { update?: EndpointUpdateFunction<E> },
 >(
   endpoint: E,
   { args }: { args: readonly [...Parameters<E>] },
 ): FetchAction<E> {
-  const key = endpoint.key(...args);
   let resolve: (value?: any | PromiseLike<any>) => void = 0 as any;
   let reject: (reason?: any) => void = 0 as any;
   const promise = new Promise<any>((a, b) => {
     [resolve, reject] = [a, b];
   });
-  const meta: FetchMeta<typeof args> = {
-    args,
-    key,
-    throttle: !endpoint.sideEffect,
+  const meta: FetchMeta = {
+    fetchedAt: Date.now(),
     resolve,
     reject,
     promise,
-    createdAt: Date.now(),
-    nm: false,
   };
 
   return {
     type: FETCH_TYPE,
-    payload: () => endpoint(...args) as any,
-    meta,
     endpoint,
+    args,
+    key: endpoint.key(...args),
+    meta,
   };
 }

package/src/controller/actions/createInvalidate.ts

@@ -0,0 +1,14 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { INVALIDATE_TYPE } from '../../actionTypes.js';
+import type { InvalidateAction } from '../../types.js';
+
+export function createInvalidate<E extends EndpointInterface>(
+  endpoint: E,
+  { args }: { args: readonly [...Parameters<E>] },
+): InvalidateAction {
+  return {
+    type: INVALIDATE_TYPE,
+    key: endpoint.key(...args),
+  };
+}

package/src/controller/actions/createInvalidateAll.ts

@@ -0,0 +1,11 @@
+import { INVALIDATEALL_TYPE } from '../../actionTypes.js';
+import type { InvalidateAllAction } from '../../types.js';
+
+export function createInvalidateAll(
+  testKey: (key: string) => boolean,
+): InvalidateAllAction {
+  return {
+    type: INVALIDATEALL_TYPE,
+    testKey,
+  };
+}

package/src/controller/actions/createMeta.ts

@@ -0,0 +1,13 @@
+import type { ActionMeta } from '../../actions.js';
+
+export function createMeta(
+  expiryLength: number,
+  fetchedAt?: number,
+): ActionMeta {
+  const now = Date.now();
+  return {
+    fetchedAt: fetchedAt ?? now,
+    date: now,
+    expiresAt: now + expiryLength,
+  };
+}

package/src/controller/actions/createOptimistic.ts

@@ -0,0 +1,32 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { createMeta } from './createMeta.js';
+import { OPTIMISTIC_TYPE } from '../../actionTypes.js';
+import type { OptimisticAction } from '../../types.js';
+import type { EndpointUpdateFunction } from '../types.js';
+
+export function createOptimistic<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  },
+>(
+  endpoint: E,
+  args: readonly [...Parameters<E>],
+  fetchedAt: number,
+): OptimisticAction<E> {
+  /* istanbul ignore next */
+  if (
+    process.env.NODE_ENV === 'development' &&
+    (endpoint.dataExpiryLength ?? 0) < 0
+  ) {
+    throw new Error('Negative expiry length are not allowed.');
+  }
+
+  return {
+    type: OPTIMISTIC_TYPE,
+    endpoint,
+    args,
+    key: endpoint.key(...args),
+    meta: createMeta(endpoint.dataExpiryLength ?? 60000, fetchedAt),
+  };
+}

package/src/controller/actions/createReset.ts

@@ -0,0 +1,9 @@
+import { RESET_TYPE } from '../../actionTypes.js';
+import type { ResetAction } from '../../types.js';
+
+export function createReset(): ResetAction {
+  return {
+    type: RESET_TYPE,
+    date: Date.now(),
+  };
+}

package/src/controller/actions/createSet.ts

@@ -0,0 +1,31 @@
+import type {
+  Denormalize,
+  Queryable,
+  SchemaArgs,
+} from '@data-client/normalizr';
+
+import { createMeta } from './createMeta.js';
+import { SET_TYPE } from '../../actionTypes.js';
+import type { SetAction } from '../../types.js';
+import ensurePojo from '../ensurePojo.js';
+
+export function createSet<S extends Queryable>(
+  schema: S,
+  {
+    args,
+    fetchedAt,
+    value,
+  }: {
+    args: readonly [...SchemaArgs<S>];
+    value: {} | ((previousValue: Denormalize<S>) => {});
+    fetchedAt?: number;
+  },
+): SetAction<S> {
+  return {
+    type: SET_TYPE,
+    schema,
+    value,
+    args: args.map(ensurePojo) as SchemaArgs<S>,
+    meta: createMeta(60000, fetchedAt),
+  };
+}

package/src/controller/{createSetResponse.ts → actions/createSetResponse.ts}

@@ -1,11 +1,12 @@
 import type { EndpointInterface, ResolveType } from '@data-client/normalizr';
 
-import ensurePojo from './ensurePojo.js';
-import { EndpointUpdateFunction } from './types.js';
-import { SET_RESPONSE_TYPE } from '../actionTypes.js';
-import type { SetResponseAction, SetResponseMeta } from '../types.js';
+import { createMeta } from './createMeta.js';
+import { SET_RESPONSE_TYPE } from '../../actionTypes.js';
+import type { SetResponseAction } from '../../types.js';
+import ensurePojo from '../ensurePojo.js';
+import { EndpointUpdateFunction } from '../types.js';
 
-export default function createSetResponse<
+export function createSetResponse<
   E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
   },
@@ -19,7 +20,7 @@ export default function createSetResponse<
   },
 ): SetResponseAction<E>;
 
-export default function createSetResponse<
+export function createSetResponse<
   E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
   },
@@ -33,7 +34,7 @@ export default function createSetResponse<
   },
 ): SetResponseAction<E>;
 
-export default function createSetResponse<
+export function createSetResponse<
   E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
   },
@@ -53,27 +54,20 @@ export default function createSetResponse<
 ): SetResponseAction<E> {
   const expiryLength: number =
     error ?
-      endpoint.errorExpiryLength ?? 1000
-    : endpoint.dataExpiryLength ?? 60000;
+      (endpoint.errorExpiryLength ?? 1000)
+    : (endpoint.dataExpiryLength ?? 60000);
   /* istanbul ignore next */
   if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
     throw new Error('Negative expiry length are not allowed.');
   }
-  const now = Date.now();
-  const meta: SetResponseMeta = {
-    args: args.map(ensurePojo),
-    fetchedAt: fetchedAt ?? now,
-    date: now,
-    expiresAt: now + expiryLength,
-    key: endpoint.key(...args),
-  };
 
-  const action: SetResponseAction<E> = {
+  return {
     type: SET_RESPONSE_TYPE,
-    payload: response,
-    endpoint: endpoint,
-    meta,
+    endpoint,
+    response,
+    args: args.map(ensurePojo),
+    key: endpoint.key(...args),
+    meta: createMeta(expiryLength, fetchedAt),
+    error,
   };
-  if (error) (action as any).error = true;
-  return action;
 }

package/src/controller/{createSubscription.ts → actions/createSubscription.ts}

@@ -1,7 +1,7 @@
 import type { EndpointInterface } from '@data-client/normalizr';
 
-import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';
-import type { SubscribeAction, UnsubscribeAction } from '../types.js';
+import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../../actionTypes.js';
+import type { SubscribeAction, UnsubscribeAction } from '../../types.js';
 
 export function createSubscription<E extends EndpointInterface>(
   endpoint: E,
@@ -10,10 +10,8 @@ export function createSubscription<E extends EndpointInterface>(
   return {
     type: SUBSCRIBE_TYPE,
     endpoint,
-    meta: {
-      args,
-      key: endpoint.key(...args),
-    },
+    args,
+    key: endpoint.key(...args),
   };
 }
 
@@ -24,9 +22,7 @@ export function createUnsubscription<E extends EndpointInterface>(
   return {
     type: UNSUBSCRIBE_TYPE,
     endpoint,
-    meta: {
-      args,
-      key: endpoint.key(...args),
-    },
+    args,
+    key: endpoint.key(...args),
   };
 }

package/src/controller/actions/index.ts

@@ -0,0 +1,13 @@
+export {
+  createSubscription,
+  createUnsubscription,
+} from './createSubscription.js';
+export { createSetResponse } from './createSetResponse.js';
+export { createSet } from './createSet.js';
+export { createReset } from './createReset.js';
+export { createOptimistic } from './createOptimistic.js';
+export { createMeta } from './createMeta.js';
+export { createInvalidateAll } from './createInvalidateAll.js';
+export { createInvalidate } from './createInvalidate.js';
+export { createFetch } from './createFetch.js';
+export { createExpireAll } from './createExpireAll.js';

package/src/index.ts

@@ -39,9 +39,7 @@ export type {
   DataClientDispatch,
   GenericDispatch,
 } from './controller/Controller.js';
-export { default as createFetch } from './controller/createFetch.js';
-export { default as createSet } from './controller/createSet.js';
-export { default as createSetResponse } from './controller/createSetResponse.js';
+export * as actions from './controller/actions/index.js';
 
 export * from './controller/types.js';
 export * as actionTypes from './actionTypes.js';

package/src/manager/LogoutManager.ts

@@ -18,7 +18,7 @@ export default class LogoutManager implements Manager {
       if (
         action.type === SET_RESPONSE_TYPE &&
         action.error &&
-        this.shouldLogout(action.payload)
+        this.shouldLogout(action.response)
       ) {
         this.handleLogout(controller);
       }

package/src/manager/NetworkManager.ts

@@ -1,6 +1,6 @@
 import { SET_RESPONSE_TYPE, FETCH_TYPE, RESET_TYPE } from '../actionTypes.js';
+import { createSetResponse } from '../controller/actions/index.js';
 import Controller from '../controller/Controller.js';
-import createSetResponse from '../controller/createSetResponse.js';
 import type {
   FetchAction,
   Manager,
@@ -62,15 +62,14 @@ export default class NetworkManager implements Manager {
             case SET_RESPONSE_TYPE:
               // only set after new state is computed
               return next(action).then(() => {
-                if (action.meta.key in this.fetched) {
+                if (action.key in this.fetched) {
                   // Note: meta *must* be set by reducer so this should be safe
-                  const error =
-                    controller.getState().meta[action.meta.key]?.error;
+                  const error = controller.getState().meta[action.key]?.error;
                   // processing errors result in state meta having error, so we should reject the promise
                   if (error) {
                     this.handleSet(
                       createSetResponse(action.endpoint, {
-                        args: action.meta.args,
+                        args: action.args,
                         response: error,
                         fetchedAt: action.meta.fetchedAt,
                         error: true,
@@ -103,7 +102,7 @@ export default class NetworkManager implements Manager {
   /** Used by DevtoolsManager to determine whether to log an action */
   skipLogging(action: ActionTypes) {
     /* istanbul ignore next */
-    return action.type === FETCH_TYPE && action.meta.key in this.fetched;
+    return action.type === FETCH_TYPE && action.key in this.fetched;
   }
 
   /** On mount */
@@ -149,15 +148,15 @@ export default class NetworkManager implements Manager {
    * Will then start a promise for a key and potentially start the network
    * fetch.
    *
-   * Uses throttle only when instructed by action meta. This is valuable
+   * Uses throttle endpoints without sideEffects. This is valuable
    * for ensures mutation requests always go through.
    */
   protected handleFetch(action: FetchAction) {
-    const fetch = action.payload;
-    const { key, throttle, resolve, reject, createdAt } = action.meta;
+    const { resolve, reject, fetchedAt } = action.meta;
+    const throttle = !action.endpoint.sideEffect;
 
     const deferedFetch = () => {
-      let promise = fetch();
+      let promise = action.endpoint(...action.args);
       const resolvePromise = (
         promise: Promise<string | number | object | null>,
       ) =>
@@ -177,7 +176,7 @@ export default class NetworkManager implements Manager {
         promise = resolvePromise(promise);
       }
       promise = promise
-        .then(data => {
+        .then(response => {
           let lastReset = this.getLastReset();
 
           /* istanbul ignore else */
@@ -189,23 +188,23 @@ export default class NetworkManager implements Manager {
           }
 
           // don't update state with promises started before last clear
-          if (createdAt >= lastReset) {
+          if (fetchedAt >= lastReset) {
             this.controller.resolve(action.endpoint, {
-              args: action.meta.args,
-              response: data,
-              fetchedAt: createdAt,
+              args: action.args,
+              response,
+              fetchedAt,
             });
           }
-          return data;
+          return response;
         })
         .catch(error => {
           const lastReset = this.getLastReset();
           // don't update state with promises started before last clear
-          if (createdAt >= lastReset) {
+          if (fetchedAt >= lastReset) {
             this.controller.resolve(action.endpoint, {
-              args: action.meta.args,
+              args: action.args,
               response: error,
-              fetchedAt: createdAt,
+              fetchedAt,
               error: true,
             });
           }
@@ -215,7 +214,7 @@ export default class NetworkManager implements Manager {
     };
 
     if (throttle) {
-      return this.throttle(key, deferedFetch, createdAt)
+      return this.throttle(action.key, deferedFetch, fetchedAt)
         .then(data => resolve(data))
         .catch(error => reject(error));
     } else {
@@ -229,16 +228,16 @@ export default class NetworkManager implements Manager {
    */
   protected handleSet(action: SetResponseAction) {
     // this can still turn out to be untrue since this is async
-    if (action.meta.key in this.fetched) {
+    if (action.key in this.fetched) {
       let promiseHandler: (value?: any) => void;
       if (action.error) {
-        promiseHandler = this.rejectors[action.meta.key];
+        promiseHandler = this.rejectors[action.key];
       } else {
-        promiseHandler = this.resolvers[action.meta.key];
+        promiseHandler = this.resolvers[action.key];
       }
-      promiseHandler(action.payload);
+      promiseHandler(action.response);
       // since we're resolved we no longer need to keep track of this promise
-      this.clear(action.meta.key);
+      this.clear(action.key);
     }
   }
 
@@ -266,7 +265,7 @@ export default class NetworkManager implements Manager {
   protected throttle(
     key: string,
     fetch: () => Promise<any>,
-    createdAt: number,
+    fetchedAt: number,
   ) {
     const lastReset = this.getLastReset();
     // we're already fetching so reuse the promise
@@ -279,7 +278,7 @@ export default class NetworkManager implements Manager {
       this.resolvers[key] = resolve;
       this.rejectors[key] = reject;
     });
-    this.fetchedAt[key] = createdAt;
+    this.fetchedAt[key] = fetchedAt;
 
     this.idleCallback(
       () => {

package/src/manager/PollingSubscription.ts

@@ -34,8 +34,8 @@ export default class PollingSubscription implements Subscription {
       throw new Error('frequency needed for polling subscription');
     this.endpoint = action.endpoint;
     this.frequency = action.endpoint.pollFrequency;
-    this.args = action.meta.args;
-    this.key = action.meta.key;
+    this.args = action.args;
+    this.key = action.key;
     this.frequencyHistogram.set(this.frequency, 1);
     this.controller = controller;
     this.connectionListener =

package/src/manager/SubscriptionManager.ts

@@ -79,7 +79,7 @@ export default class SubscriptionManager<S extends SubscriptionConstructable>
    *
    */
   protected handleSubscribe(action: SubscribeAction) {
-    const key = action.meta.key;
+    const key = action.key;
 
     if (key in this.subscriptions) {
       const frequency = action.endpoint.pollFrequency;
@@ -96,7 +96,7 @@ export default class SubscriptionManager<S extends SubscriptionConstructable>
    *
    */
   protected handleUnsubscribe(action: UnsubscribeAction) {
-    const key = action.meta.key;
+    const key = action.key;
 
     /* istanbul ignore else */
     if (key in this.subscriptions) {

package/src/manager/__tests__/__snapshots__/pollingSubscription.ts.snap

@@ -9,17 +9,14 @@ exports[`PollingSubscription fresh data cleanup() should not run even if interva
 exports[`PollingSubscription fresh data should call after period 1`] = `
 [
   {
+    "args": [],
     "endpoint": [Function],
+    "key": "test.com",
     "meta": {
-      "args": [],
-      "key": "test.com",
-      "nm": false,
       "promise": Promise {},
       "reject": [Function],
       "resolve": [Function],
-      "throttle": true,
     },
-    "payload": [Function],
     "type": "rdc/fetch",
   },
 ]
@@ -28,17 +25,14 @@ exports[`PollingSubscription fresh data should call after period 1`] = `
 exports[`PollingSubscription fresh data should call after period 2`] = `
 [
   {
+    "args": [],
     "endpoint": [Function],
+    "key": "test.com",
     "meta": {
-      "args": [],
-      "key": "test.com",
-      "nm": false,
       "promise": Promise {},
       "reject": [Function],
       "resolve": [Function],
-      "throttle": true,
     },
-    "payload": [Function],
     "type": "rdc/fetch",
   },
 ]

package/src/manager/__tests__/logoutManager.ts

@@ -2,7 +2,7 @@ import { CoolerArticleResource } from '__tests__/new';
 
 import { Controller, initialState } from '../..';
 import { FETCH_TYPE, RESET_TYPE } from '../../actionTypes';
-import createSetResponse from '../../controller/createSetResponse';
+import { createSetResponse } from '../../controller/actions';
 import LogoutManager from '../LogoutManager.js';
 
 function onError(e: any) {