@data-client/core 0.13.1 → 0.14.0

package/src/manager/NetworkManager.ts

@@ -1,7 +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 RIC from '../state/RIC.js';
 import type {
   FetchAction,
   Manager,
@@ -63,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,
@@ -104,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 */
@@ -150,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>,
       ) =>
@@ -178,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 */
@@ -190,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,
             });
           }
@@ -216,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 {
@@ -230,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);
     }
   }
 
@@ -267,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
@@ -280,13 +278,13 @@ export default class NetworkManager implements Manager {
       this.resolvers[key] = resolve;
       this.rejectors[key] = reject;
     });
-    this.fetchedAt[key] = createdAt;
+    this.fetchedAt[key] = fetchedAt;
 
-    // since our real promise is resolved via the wrapReducer(),
-    // we should just stop all errors here.
-    // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)
-    RIC(
+    this.idleCallback(
       () => {
+        // since our real promise is resolved via the wrapReducer(),
+        // we should just stop all errors here.
+        // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)
         fetch().catch(() => null);
       },
       { timeout: 500 },
@@ -294,4 +292,15 @@ export default class NetworkManager implements Manager {
 
     return this.fetched[key];
   }
+
+  /** Calls the callback when client is not 'busy' with high priority interaction tasks
+   *
+   * Override for platform-specific implementations
+   */
+  protected idleCallback(
+    callback: (...args: any[]) => void,
+    options?: IdleRequestOptions,
+  ) {
+    callback();
+  }
 }

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) {

package/src/manager/__tests__/networkManager.ts

@@ -2,11 +2,11 @@ import { Endpoint } from '@data-client/endpoint';
 import { Article, ArticleResource } from '__tests__/new';
 
 import { SET_RESPONSE_TYPE } from '../../actionTypes';
+import { createFetch } from '../../controller/actions';
 import Controller from '../../controller/Controller';
-import createFetch from '../../controller/createFetch';
 import NetworkManager from '../../manager/NetworkManager';
 import { initialState } from '../../state/reducer/createReducer';
-import { Middleware } from '../../types';
+import { Middleware, SetResponseAction } from '../../types';
 
 describe('NetworkManager', () => {
   const manager = new NetworkManager();
@@ -154,18 +154,21 @@ describe('NetworkManager', () => {
 
       middleware(API)(next)(fetchResolveAction);
 
-      const data = await fetchResolveAction.payload();
+      const response = await fetchResolveAction.endpoint(
+        ...fetchResolveAction.args,
+      );
 
       // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
 
-      const action = {
+      const action: SetResponseAction = {
         type: SET_RESPONSE_TYPE,
         endpoint: fetchResolveAction.endpoint,
-        payload: data,
+        response,
+        args: fetchResolveAction.args,
+        key: fetchResolveAction.key,
+        error: expect.anything(),
         meta: {
-          args: fetchResolveAction.meta.args,
-          key: fetchResolveAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
           fetchedAt: expect.any(Number),
@@ -187,18 +190,21 @@ describe('NetworkManager', () => {
 
       middleware(API)(next)(fetchSetWithUpdatersAction);
 
-      const data = await fetchSetWithUpdatersAction.payload();
+      const response = await fetchSetWithUpdatersAction.endpoint(
+        ...fetchSetWithUpdatersAction.args,
+      );
 
       // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
 
-      const action = {
+      const action: SetResponseAction = {
         type: SET_RESPONSE_TYPE,
         endpoint: fetchSetWithUpdatersAction.endpoint,
-        payload: data,
+        response,
+        args: fetchSetWithUpdatersAction.args,
+        key: fetchSetWithUpdatersAction.key,
+        error: expect.anything(),
         meta: {
-          args: fetchSetWithUpdatersAction.meta.args,
-          key: fetchSetWithUpdatersAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
           fetchedAt: expect.any(Number),
@@ -220,18 +226,21 @@ describe('NetworkManager', () => {
 
       middleware(API)(next)(fetchRpcWithUpdatersAction);
 
-      const data = await fetchRpcWithUpdatersAction.payload();
+      const response = await fetchRpcWithUpdatersAction.endpoint(
+        ...fetchRpcWithUpdatersAction.args,
+      );
 
       // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
 
-      const action = {
+      const action: SetResponseAction = {
         type: SET_RESPONSE_TYPE,
         endpoint: fetchRpcWithUpdatersAction.endpoint,
-        payload: data,
+        response,
+        args: fetchRpcWithUpdatersAction.args,
+        key: fetchRpcWithUpdatersAction.key,
+        error: expect.anything(),
         meta: {
-          args: fetchRpcWithUpdatersAction.meta.args,
-          key: fetchRpcWithUpdatersAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
           fetchedAt: expect.any(Number),
@@ -253,7 +262,9 @@ describe('NetworkManager', () => {
 
       middleware(API)(next)(fetchRpcWithUpdatersAndOptimisticAction);
 
-      const data = await fetchRpcWithUpdatersAndOptimisticAction.payload();
+      const response = await fetchRpcWithUpdatersAndOptimisticAction.endpoint(
+        ...fetchRpcWithUpdatersAndOptimisticAction.args,
+      );
 
       expect(next).toHaveBeenCalled();
       // mutations resolve before dispatch, so we must wait for next tick to see set
@@ -261,10 +272,11 @@ describe('NetworkManager', () => {
       expect(dispatch).toHaveBeenCalledWith({
         type: SET_RESPONSE_TYPE,
         endpoint: fetchRpcWithUpdatersAndOptimisticAction.endpoint,
-        payload: data,
+        response,
+        args: fetchRpcWithUpdatersAndOptimisticAction.args,
+        key: fetchRpcWithUpdatersAndOptimisticAction.key,
+        error: expect.anything(),
         meta: {
-          args: fetchRpcWithUpdatersAndOptimisticAction.meta.args,
-          key: fetchRpcWithUpdatersAndOptimisticAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
           fetchedAt: expect.any(Number),
@@ -286,7 +298,7 @@ describe('NetworkManager', () => {
         endpoint: detailEndpoint.extend({ dataExpiryLength: 314 }),
       });
 
-      await fetchResolveAction.payload();
+      await fetchResolveAction.endpoint(...fetchResolveAction.args);
 
       expect(dispatch).toHaveBeenCalled();
       const { meta } = dispatch.mock.calls[0][0];
@@ -307,7 +319,7 @@ describe('NetworkManager', () => {
         endpoint: detailEndpoint.extend({ dataExpiryLength: undefined }),
       });
 
-      await fetchResolveAction.payload();
+      await fetchResolveAction.endpoint(...fetchResolveAction.args);
 
       expect(dispatch).toHaveBeenCalled();
       const { meta } = dispatch.mock.calls[0][0];
@@ -330,9 +342,9 @@ describe('NetworkManager', () => {
         expect(next).not.toHaveBeenCalled();
         expect(dispatch).toHaveBeenCalledWith({
           type: SET_RESPONSE_TYPE,
-          payload: error,
+          response: error,
+          key: fetchRejectAction.key,
           meta: {
-            key: fetchRejectAction.meta.key,
             date: expect.any(Number),
             expiresAt: expect.any(Number),
           },

package/src/manager/__tests__/pollingSubscription.ts

@@ -1,8 +1,8 @@
 import { Endpoint } from '@data-client/endpoint';
 import { Article, PollingArticleResource } from '__tests__/new';
 
+import { createSubscription } from '../../controller/actions/createSubscription';
 import Controller from '../../controller/Controller';
-import { createSubscription } from '../../controller/createSubscription';
 import { initialState } from '../../state/reducer/createReducer';
 import ConnectionListener from '../ConnectionListener';
 import DefaultConnectionListener from '../DefaultConnectionListener';
@@ -178,13 +178,13 @@ describe('PollingSubscription', () => {
       jest.advanceTimersByTime(5000);
       expect(dispatch.mock.calls.length).toBe(1);
       dispatch.mock.calls[0].forEach((element: any) => {
-        delete element?.meta?.createdAt;
+        delete element?.meta?.fetchedAt;
       });
       expect(dispatch.mock.calls[0]).toMatchSnapshot();
       jest.advanceTimersByTime(5000);
       expect(dispatch.mock.calls.length).toBe(2);
       dispatch.mock.calls[1].forEach((element: any) => {
-        delete element?.meta?.createdAt;
+        delete element?.meta?.fetchedAt;
       });
 
       expect(dispatch.mock.calls[1]).toMatchSnapshot();

package/src/manager/__tests__/subscriptionManager.ts

@@ -48,32 +48,28 @@ describe('SubscriptionManager', () => {
 
   describe('middleware', () => {
     function createSubscribeAction(
-      payload: Record<string, any>,
+      response: Record<string, any>,
       reject = false,
     ): SubscribeAction {
       const fetch =
         reject ?
           () => Promise.reject(new Error('Failed'))
-        : () => Promise.resolve(payload);
+        : () => Promise.resolve(response);
       return {
         type: SUBSCRIBE_TYPE,
-        endpoint: PollingArticleResource.get,
-        meta: {
-          key: PollingArticleResource.get.key({ id: payload.id }),
-          args: [{ id: payload.id }],
-        },
+        endpoint: PollingArticleResource.get.extend({ fetch }),
+        args: [{ id: response.id }],
+        key: PollingArticleResource.get.key({ id: response.id }),
       };
     }
     function createUnsubscribeAction(
-      payload: Record<string, any>,
+      response: Record<string, any>,
     ): UnsubscribeAction {
       return {
         type: UNSUBSCRIBE_TYPE,
         endpoint: PollingArticleResource.get,
-        meta: {
-          key: PollingArticleResource.get.key({ id: payload.id }),
-          args: [{ id: payload.id }],
-        },
+        key: PollingArticleResource.get.key({ id: response.id }),
+        args: [{ id: response.id }],
       };
     }
 
@@ -93,14 +89,14 @@ describe('SubscriptionManager', () => {
       middleware(API)(next)(action);
 
       expect(next).not.toHaveBeenCalled();
-      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+      expect((manager as any).subscriptions[action.key]).toBeDefined();
     });
     it('subscribe should add a subscription (no frequency)', () => {
       const action = createSubscribeAction({ id: 597 });
       middleware(API)(next)(action);
 
       expect(next).not.toHaveBeenCalled();
-      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+      expect((manager as any).subscriptions[action.key]).toBeDefined();
     });
 
     it('subscribe with same should call subscription.add', () => {
@@ -108,20 +104,20 @@ describe('SubscriptionManager', () => {
       middleware(API)(next)(action);
 
       expect(
-        (manager as any).subscriptions[action.meta.key].add.mock.calls.length,
+        (manager as any).subscriptions[action.key].add.mock.calls.length,
       ).toBe(1);
       middleware(API)(next)(action);
       expect(
-        (manager as any).subscriptions[action.meta.key].add.mock.calls.length,
+        (manager as any).subscriptions[action.key].add.mock.calls.length,
       ).toBe(2);
     });
     it('subscribe with another should create another', () => {
       const action = createSubscribeAction({ id: 7, title: 'four cakes' });
       middleware(API)(next)(action);
 
-      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+      expect((manager as any).subscriptions[action.key]).toBeDefined();
       expect(
-        (manager as any).subscriptions[action.meta.key].add.mock.calls.length,
+        (manager as any).subscriptions[action.key].add.mock.calls.length,
       ).toBe(0);
     });
     it('subscribe with another should not call previous', () => {
@@ -134,13 +130,13 @@ describe('SubscriptionManager', () => {
 
     it('unsubscribe should delete when remove returns true', () => {
       const action = createUnsubscribeAction({ id: 7, title: 'four cakes' });
-      (manager as any).subscriptions[action.meta.key].remove.mockImplementation(
+      (manager as any).subscriptions[action.key].remove.mockImplementation(
         () => true,
       );
 
       middleware(API)(next)(action);
 
-      expect((manager as any).subscriptions[action.meta.key]).not.toBeDefined();
+      expect((manager as any).subscriptions[action.key]).not.toBeDefined();
     });
 
     it('unsubscribe should delete when remove returns true (no frequency)', () => {
@@ -149,27 +145,26 @@ describe('SubscriptionManager', () => {
       );
 
       const action = createUnsubscribeAction({ id: 50, title: 'four cakes' });
-      (manager as any).subscriptions[action.meta.key].remove.mockImplementation(
+      (manager as any).subscriptions[action.key].remove.mockImplementation(
         () => true,
       );
 
       middleware(API)(next)(action);
 
-      expect((manager as any).subscriptions[action.meta.key]).not.toBeDefined();
+      expect((manager as any).subscriptions[action.key]).not.toBeDefined();
     });
 
     it('unsubscribe should not delete when remove returns false', () => {
       const action = createUnsubscribeAction({ id: 5, title: 'four cakes' });
-      (manager as any).subscriptions[action.meta.key].remove.mockImplementation(
+      (manager as any).subscriptions[action.key].remove.mockImplementation(
         () => false,
       );
 
       middleware(API)(next)(action);
 
-      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+      expect((manager as any).subscriptions[action.key]).toBeDefined();
       expect(
-        (manager as any).subscriptions[action.meta.key].remove.mock.calls
-          .length,
+        (manager as any).subscriptions[action.key].remove.mock.calls.length,
       ).toBe(1);
     });
 
@@ -181,7 +176,7 @@ describe('SubscriptionManager', () => {
 
       middleware(API)(next)(action);
 
-      expect((manager as any).subscriptions[action.meta.key]).not.toBeDefined();
+      expect((manager as any).subscriptions[action.key]).not.toBeDefined();
 
       expect(spy.mock.calls[0]).toMatchInlineSnapshot(`
         [