@data-client/core 0.1.0 → 0.2.0

package/src/manager/__tests__/manager.ts

@@ -1,6 +1,6 @@
 import Controller from '../../controller/Controller';
 import { Middleware } from '../../middlewareTypes';
-import { CombinedActionTypes } from '../../types';
+import { ActionTypes } from '../../types';
 import NetworkManager from '../NetworkManager';
 
 const middleware: Middleware = new NetworkManager().getMiddleware();
@@ -9,9 +9,7 @@ it('middlewares should compose with non-rest-hooks middlewares', () => {
     type: 'BOB';
     payload: any;
   };
-  const dispatch = jest.fn(
-    async (action: CombinedActionTypes | AnotherAction) => {},
-  );
+  const dispatch = jest.fn(async (action: ActionTypes | AnotherAction) => {});
   const ctrl = new Controller({ dispatch });
   const API: typeof ctrl & { controller: typeof ctrl } = Object.create(ctrl, {
     controller: { value: ctrl },

package/src/manager/__tests__/networkManager.ts

@@ -1,7 +1,7 @@
 import { Endpoint } from '@data-client/endpoint';
 import { Article, ArticleResource } from '__tests__/new';
 
-import { RECEIVE_TYPE } from '../../actionTypes';
+import { SET_TYPE } from '../../actionTypes';
 import Controller from '../../controller/Controller';
 import createFetch from '../../controller/createFetch';
 import NetworkManager from '../../manager/NetworkManager';
@@ -17,7 +17,7 @@ describe('NetworkManager', () => {
   });
   let errorspy: jest.SpyInstance;
   beforeEach(() => {
-    errorspy = jest.spyOn(global.console, 'error');
+    errorspy = jest.spyOn(global.console, 'error').mockImplementation(() => {});
   });
   afterEach(() => {
     errorspy.mockRestore();
@@ -26,7 +26,7 @@ describe('NetworkManager', () => {
   it('getState() should have initialState before middleware run', () => {
     class Hacked extends NetworkManager {
       getHacked() {
-        return this.getState();
+        return this.controller.getState();
       }
     }
     const hacked = new Hacked();
@@ -162,13 +162,11 @@ describe('NetworkManager', () => {
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
-        type: RECEIVE_TYPE,
+        type: SET_TYPE,
         endpoint: fetchResolveAction.endpoint,
         payload: data,
         meta: {
-          schema: fetchResolveAction.meta.schema,
           args: fetchResolveAction.meta.args,
-          update: fetchResolveAction.meta.update,
           key: fetchResolveAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
@@ -197,13 +195,11 @@ describe('NetworkManager', () => {
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
-        type: RECEIVE_TYPE,
+        type: SET_TYPE,
         endpoint: fetchReceiveWithUpdatersAction.endpoint,
         payload: data,
         meta: {
-          update: expect.any(Function),
           args: fetchReceiveWithUpdatersAction.meta.args,
-          schema: fetchReceiveWithUpdatersAction.meta.schema,
           key: fetchReceiveWithUpdatersAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
@@ -232,13 +228,11 @@ describe('NetworkManager', () => {
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
-        type: RECEIVE_TYPE,
+        type: SET_TYPE,
         endpoint: fetchRpcWithUpdatersAction.endpoint,
         payload: data,
         meta: {
           args: fetchRpcWithUpdatersAction.meta.args,
-          update: expect.any(Function),
-          schema: fetchRpcWithUpdatersAction.meta.schema,
           key: fetchRpcWithUpdatersAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
@@ -267,13 +261,11 @@ describe('NetworkManager', () => {
       // mutations resolve before dispatch, so we must wait for next tick to see receive
       await new Promise(resolve => setTimeout(resolve, 0));
       expect(dispatch).toHaveBeenCalledWith({
-        type: RECEIVE_TYPE,
+        type: SET_TYPE,
         endpoint: fetchRpcWithUpdatersAndOptimisticAction.endpoint,
         payload: data,
         meta: {
           args: fetchRpcWithUpdatersAndOptimisticAction.meta.args,
-          update: expect.any(Function),
-          schema: fetchRpcWithUpdatersAndOptimisticAction.meta.schema,
           key: fetchRpcWithUpdatersAndOptimisticAction.meta.key,
           date: expect.any(Number),
           expiresAt: expect.any(Number),
@@ -339,10 +331,9 @@ describe('NetworkManager', () => {
       } catch (error) {
         expect(next).not.toHaveBeenCalled();
         expect(dispatch).toHaveBeenCalledWith({
-          type: RECEIVE_TYPE,
+          type: SET_TYPE,
           payload: error,
           meta: {
-            schema: fetchRejectAction.meta.schema,
             key: fetchRejectAction.meta.key,
             date: expect.any(Number),
             expiresAt: expect.any(Number),
@@ -366,7 +357,6 @@ describe('NetworkManager', () => {
           ...fetchRejectAction,
           meta: {
             ...fetchRejectAction.meta,
-            options: { errorExpiryLength: 1234 },
           },
         });
       } catch (error) {
@@ -390,10 +380,6 @@ describe('NetworkManager', () => {
           ...fetchRejectAction,
           meta: {
             ...fetchRejectAction.meta,
-            options: {
-              ...fetchRejectAction.meta.options,
-              errorExpiryLength: undefined,
-            },
           },
         });
       } catch (error) {
@@ -402,25 +388,5 @@ describe('NetworkManager', () => {
         expect(meta.expiresAt - meta.date).toBe(7);
       }
     });
-
-    it('getLastReset() should handle Date object', async () => {
-      const mgr = new NetworkManager();
-      jest.spyOn(mgr, 'getState' as any).mockImplementation((): any => ({
-        ...initialState,
-        lastReset: new Date(0),
-      }));
-
-      expect((mgr as any).getLastReset()).toBeLessThan(Date.now());
-    });
-
-    it('getLastReset() should handle null', async () => {
-      const mgr = new NetworkManager();
-      jest.spyOn(mgr, 'getState' as any).mockImplementation((): any => ({
-        ...initialState,
-        lastReset: null,
-      }));
-
-      expect((mgr as any).getLastReset()).toBeLessThan(Date.now());
-    });
   });
 });

package/src/manager/__tests__/pollingSubscription.ts

@@ -1,5 +1,8 @@
-import { PollingArticleResource } from '__tests__/legacy-3';
+import { Endpoint } from '@data-client/endpoint';
+import { Article, PollingArticleResource } from '__tests__/new';
 
+import Controller from '../../controller/Controller';
+import { createSubscription } from '../../controller/createSubscription';
 import { initialState } from '../../state/reducer/createReducer';
 import ConnectionListener from '../ConnectionListener';
 import DefaultConnectionListener from '../DefaultConnectionListener';
@@ -55,6 +58,11 @@ class MockConnectionListener implements ConnectionListener {
   }
 }
 
+const makeState = (key: string, time: number) => () => ({
+  ...initialState,
+  meta: { [key]: { date: time, expiresAt: Infinity } },
+});
+
 function onError(e: any) {
   e.preventDefault();
 }
@@ -68,192 +76,277 @@ afterEach(() => {
 });
 
 describe('PollingSubscription', () => {
-  const dispatch = jest.fn();
   const a = () => Promise.resolve({ id: 5, title: 'hi' });
   const fetch = jest.fn(a);
-  let sub: PollingSubscription;
-
-  beforeAll(() => {
-    jest.useFakeTimers();
-    sub = new PollingSubscription(
-      {
-        key: 'test.com',
-        schema: PollingArticleResource,
-        fetch,
-        frequency: 5000,
-        getState: () => initialState,
-      },
-      dispatch,
-    );
-  });
-  afterAll(() => {
-    jest.useRealTimers();
-  });
-
-  afterAll(() => {
-    sub.cleanup();
-  });
-
-  it('should throw on undefined frequency in construction', () => {
-    expect(
-      () =>
-        new PollingSubscription(
-          {
-            key: 'test.com',
-            schema: PollingArticleResource,
-            fetch,
-            getState: () => initialState,
-          },
-          dispatch,
-        ),
-    ).toThrow();
+  const endpoint = new Endpoint(fetch, {
+    schema: Article,
+    key: () => 'test.com',
+    pollFrequency: 5000,
   });
 
-  it('should call immediately', () => {
-    jest.advanceTimersByTime(1);
-    expect(dispatch.mock.calls.length).toBe(1);
-  });
+  describe('existing data', () => {
+    it('should wait to call for fresh data', () => {
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch });
+      (controller as any).getState = makeState('test.com', Date.now());
 
-  it('should call after period', () => {
-    dispatch.mockReset();
-    jest.advanceTimersByTime(5000);
-    expect(dispatch.mock.calls.length).toBe(1);
-    dispatch.mock.calls[0].forEach((element: any) => {
-      delete element?.meta?.createdAt;
-    });
-    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;
+      jest.useFakeTimers();
+      const sub2 = new PollingSubscription(
+        createSubscription(endpoint, { args: [] }),
+        controller,
+      );
+      expect(dispatch.mock.calls.length).toBe(0);
+      jest.advanceTimersByTime(4990);
+      expect(dispatch.mock.calls.length).toBe(0);
+      jest.advanceTimersByTime(20);
+      expect(dispatch.mock.calls.length).toBe(1);
+      jest.advanceTimersByTime(5000);
+      expect(dispatch.mock.calls.length).toBe(2);
+      jest.advanceTimersByTime(2000);
+      expect(dispatch.mock.calls.length).toBe(2);
+      sub2.cleanup();
+      jest.useRealTimers();
     });
 
-    expect(dispatch.mock.calls[1]).toMatchSnapshot();
-  });
+    it('should only run once with multiple simultaneous starts', () => {
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch });
+      (controller as any).getState = () => initialState;
 
-  describe('add()', () => {
-    it('should take smaller frequency when another is added', () => {
-      sub.add(1000);
-      jest.advanceTimersByTime(1000 * 4);
-      expect(dispatch.mock.calls.length).toBe(2 + 4);
+      jest.useFakeTimers();
+      const sub2 = new PollingSubscription(
+        createSubscription(endpoint, { args: [] }),
+        controller,
+      );
+      sub2.add(1000);
+      sub2.add(1000);
+      sub2.add(1000);
+      jest.advanceTimersByTime(1);
+      expect(dispatch.mock.calls.length).toBe(1);
+      jest.advanceTimersByTime(999);
+      expect(dispatch.mock.calls.length).toBe(2);
+      jest.advanceTimersByTime(10);
+      sub2.remove(1000);
+      sub2.remove(1000);
+      sub2.remove(1000);
+      sub2.cleanup();
+      jest.useRealTimers();
     });
+  });
 
-    it('should not change frequency if same is added', () => {
-      dispatch.mockClear();
-      sub.add(1000);
-      jest.advanceTimersByTime(1000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
+  describe('fresh data', () => {
+    const dispatch = jest.fn();
+    const controller = new Controller({ dispatch });
+    (controller as any).getState = makeState('test.com', 0);
+    let sub: PollingSubscription;
+
+    beforeAll(() => {
+      jest.useFakeTimers();
+      sub = new PollingSubscription(
+        createSubscription(endpoint, { args: [] }),
+        controller,
+      );
     });
-
-    it('should not change frequency if larger is added', () => {
-      dispatch.mockClear();
-      sub.add(7000);
-      sub.add(8000);
-      jest.advanceTimersByTime(1000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
+    afterAll(() => {
+      sub.cleanup();
+      jest.useRealTimers();
     });
 
-    it('should do nothing if frequency is undefined', () => {
-      dispatch.mockClear();
-      sub.add(undefined);
-      jest.advanceTimersByTime(1000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
+    it('should throw on undefined frequency in construction', () => {
+      expect(
+        () =>
+          new PollingSubscription(
+            createSubscription(
+              new Endpoint(fetch, {
+                schema: Article,
+                key: () => 'test.com',
+              }),
+              { args: [] },
+            ),
+            controller,
+          ),
+      ).toThrow();
     });
-  });
 
-  describe('remove()', () => {
-    it('should not change frequency if only partially removed', () => {
-      dispatch.mockClear();
-      sub.remove(1000);
-      jest.advanceTimersByTime(1000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
+    it('should call immediately', () => {
+      jest.advanceTimersByTime(1);
+      expect(dispatch.mock.calls.length).toBe(1);
     });
 
-    it('should not change frequency if only larger removed', () => {
-      dispatch.mockClear();
-      sub.remove(7000);
-      jest.advanceTimersByTime(1000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
-    });
+    it('should call after period', () => {
+      dispatch.mockReset();
+      jest.advanceTimersByTime(5000);
+      expect(dispatch.mock.calls.length).toBe(1);
+      dispatch.mock.calls[0].forEach((element: any) => {
+        delete element?.meta?.createdAt;
+      });
+      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;
+      });
 
-    it('should go back to fastest if smallest frequency is removed completely', () => {
-      sub.remove(1000);
-      jest.advanceTimersByTime(1000);
-      dispatch.mockClear();
-      jest.advanceTimersByTime(5000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
+      expect(dispatch.mock.calls[1]).toMatchSnapshot();
     });
 
-    it('should do nothing if frequency is not registered', () => {
-      const oldError = console.error;
-      const spy = (console.error = jest.fn());
-
-      sub.remove(1000);
-      dispatch.mockClear();
-      jest.advanceTimersByTime(5000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
-
-      expect(spy.mock.calls[0]).toMatchInlineSnapshot(`
-        [
-          "Mismatched remove: 1000 is not subscribed for test.com",
-        ]
-      `);
-      console.error = oldError;
+    describe('add()', () => {
+      it('should take smaller frequency when another is added', () => {
+        sub.add(1000);
+        jest.advanceTimersByTime(1000 * 4);
+        expect(dispatch.mock.calls.length).toBe(2 + 4);
+      });
+
+      it('should not change frequency if same is added', () => {
+        dispatch.mockClear();
+        sub.add(1000);
+        jest.advanceTimersByTime(1000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
+
+      it('should not change frequency if larger is added', () => {
+        dispatch.mockClear();
+        sub.add(7000);
+        sub.add(8000);
+        jest.advanceTimersByTime(1000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
+
+      it('should do nothing if frequency is undefined', () => {
+        dispatch.mockClear();
+        sub.add(undefined);
+        jest.advanceTimersByTime(1000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
     });
 
-    it('should do nothing if frequency is undefined', () => {
-      sub.remove(undefined);
-      dispatch.mockClear();
-      jest.advanceTimersByTime(5000 * 13);
-      expect(dispatch.mock.calls.length).toBe(13);
+    describe('remove()', () => {
+      it('should not change frequency if only partially removed', () => {
+        dispatch.mockClear();
+        sub.remove(1000);
+        jest.advanceTimersByTime(1000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
+
+      it('should not change frequency if only larger removed', () => {
+        dispatch.mockClear();
+        sub.remove(7000);
+        jest.advanceTimersByTime(1000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
+
+      it('should go back to fastest if smallest frequency is removed completely', () => {
+        sub.remove(1000);
+        jest.advanceTimersByTime(1000);
+        dispatch.mockClear();
+        jest.advanceTimersByTime(5000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
+
+      it('should do nothing if frequency is not registered', () => {
+        const oldError = console.error;
+        const spy = (console.error = jest.fn());
+
+        sub.remove(1000);
+        dispatch.mockClear();
+        jest.advanceTimersByTime(5000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+
+        expect(spy.mock.calls[0]).toMatchInlineSnapshot(`
+          [
+            "Mismatched remove: 1000 is not subscribed for test.com",
+          ]
+        `);
+        console.error = oldError;
+      });
+
+      it('should do nothing if frequency is undefined', () => {
+        sub.remove(undefined);
+        dispatch.mockClear();
+        jest.advanceTimersByTime(5000 * 13);
+        expect(dispatch.mock.calls.length).toBe(13);
+      });
+
+      it('should return false until completely empty, then return true', () => {
+        const controller = new Controller({ dispatch });
+        (controller as any).getState = makeState('test.com', 0);
+
+        const sub = new PollingSubscription(
+          createSubscription(endpoint, { args: [] }),
+          controller,
+        );
+        sub.add(5000);
+        sub.add(7000);
+        expect(sub.remove(5000)).toBe(false);
+        expect(sub.remove(5000)).toBe(false);
+        expect(sub.remove(7000)).toBe(true);
+      });
     });
 
-    it('should return false until completely empty, then return true', () => {
-      const sub = new PollingSubscription(
-        {
-          key: 'test.com',
-          schema: PollingArticleResource,
-          fetch,
-          frequency: 5000,
-          getState: () => initialState,
-        },
-        dispatch,
-      );
-      sub.add(5000);
-      sub.add(7000);
-      expect(sub.remove(5000)).toBe(false);
-      expect(sub.remove(5000)).toBe(false);
-      expect(sub.remove(7000)).toBe(true);
+    describe('cleanup()', () => {
+      let warnSpy: jest.SpyInstance;
+      afterEach(() => {
+        warnSpy.mockRestore();
+      });
+      beforeEach(() => (warnSpy = jest.spyOn(console, 'warn')));
+
+      it('should stop all timers', () => {
+        dispatch.mockClear();
+        sub.cleanup();
+        jest.advanceTimersByTime(5000 * 13);
+        expect(dispatch.mock.calls.length).toBe(0);
+      });
+      it('should be idempotent', () => {
+        sub.cleanup();
+      });
+      it('should not run even if interval not cancelled', () => {
+        const controller = new Controller({ dispatch });
+        (controller as any).getState = makeState('test.com', 0);
+
+        sub.cleanup();
+        sub = new PollingSubscription(
+          createSubscription(endpoint.extend({ key: () => 'test.com2' }), {
+            args: [],
+          }),
+          controller,
+        );
+        sub.add(5000);
+        jest.runOnlyPendingTimers();
+        delete (sub as any).intervalId;
+        jest.advanceTimersByTime(5000 * 13);
+
+        expect(dispatch.mock.calls.length).toBe(1);
+        expect(warnSpy.mock.calls.length).toBe(13);
+        expect(warnSpy.mock.calls[0]).toMatchSnapshot();
+      });
     });
   });
 
-  describe('cleanup()', () => {
-    it('should stop all timers', () => {
-      dispatch.mockClear();
-      sub.cleanup();
-      jest.advanceTimersByTime(5000 * 13);
-      expect(dispatch.mock.calls.length).toBe(0);
+  describe('offline support', () => {
+    beforeAll(() => {
+      jest.useFakeTimers();
     });
-    it('should be idempotent', () => {
-      sub.cleanup();
+    afterAll(() => {
+      jest.useRealTimers();
     });
-  });
 
-  describe('offline support', () => {
     function createMocks(listener: ConnectionListener) {
       const dispatch = jest.fn();
       const a = () => Promise.resolve({ id: 5, title: 'hi' });
       const fetch = jest.fn(a);
+      const endpoint = new Endpoint(fetch, {
+        schema: Article,
+        key: () => 'test.com',
+        pollFrequency: 5000,
+      });
+      const controller = new Controller({ dispatch });
+      (controller as any).getState = makeState('test.com', 0);
 
       const pollingSubscription = new PollingSubscription(
-        {
-          key: 'test.com',
-          schema: PollingArticleResource,
-          fetch,
-          frequency: 5000,
-          getState: () => initialState,
-        },
-        dispatch,
+        createSubscription(endpoint, {
+          args: [],
+        }),
+        controller,
         listener,
       );
       jest.advanceTimersByTime(1);
@@ -298,6 +391,21 @@ describe('PollingSubscription', () => {
       expect(listener.onlineHandlers.length).toBe(0);
     });
 
+    it('should not run when timeoutId is deleted after coming online', () => {
+      const listener = new MockConnectionListener(false);
+      const { dispatch, pollingSubscription } = createMocks(listener);
+      expect(dispatch.mock.calls.length).toBe(0);
+
+      listener.trigger('online');
+      delete (pollingSubscription as any).startId;
+      jest.advanceTimersByTime(1);
+      expect(dispatch.mock.calls.length).toBe(0);
+      jest.advanceTimersByTime(5000);
+      expect(dispatch.mock.calls.length).toBe(0);
+      expect(listener.offlineHandlers.length).toBe(1);
+      expect(listener.onlineHandlers.length).toBe(0);
+    });
+
     it('should stop dispatching when offline again', () => {
       const listener = new MockConnectionListener(true);
       const { dispatch } = createMocks(listener);