@data-client/core 0.1.0

package/src/manager/__tests__/pollingSubscription.ts

@@ -0,0 +1,313 @@
+import { PollingArticleResource } from '__tests__/legacy-3';
+
+import { initialState } from '../../state/reducer/createReducer';
+import ConnectionListener from '../ConnectionListener';
+import DefaultConnectionListener from '../DefaultConnectionListener';
+import PollingSubscription from '../PollingSubscription';
+
+class MockConnectionListener implements ConnectionListener {
+  declare online: boolean;
+  declare onlineHandlers: (() => void)[];
+  declare offlineHandlers: (() => void)[];
+
+  constructor(online: boolean) {
+    this.online = online;
+    this.onlineHandlers = [];
+    this.offlineHandlers = [];
+  }
+
+  isOnline() {
+    return this.online;
+  }
+
+  addOnlineListener(handler: () => void) {
+    this.onlineHandlers.push(handler);
+  }
+
+  removeOnlineListener(handler: () => void) {
+    this.onlineHandlers = this.onlineHandlers.filter(h => h !== handler);
+  }
+
+  addOfflineListener(handler: () => void) {
+    this.offlineHandlers.push(handler);
+  }
+
+  removeOfflineListener(handler: () => void) {
+    this.offlineHandlers = this.offlineHandlers.filter(h => h !== handler);
+  }
+
+  trigger(event: 'offline' | 'online') {
+    switch (event) {
+      case 'offline':
+        this.online = false;
+        this.offlineHandlers.forEach(t => t());
+        break;
+      case 'online':
+        this.online = true;
+        this.onlineHandlers.forEach(t => t());
+        break;
+    }
+  }
+
+  reset() {
+    this.offlineHandlers = [];
+    this.onlineHandlers = [];
+  }
+}
+
+function onError(e: any) {
+  e.preventDefault();
+}
+beforeEach(() => {
+  if (typeof addEventListener === 'function')
+    addEventListener('error', onError);
+});
+afterEach(() => {
+  if (typeof removeEventListener === 'function')
+    removeEventListener('error', onError);
+});
+
+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();
+  });
+
+  it('should call immediately', () => {
+    jest.advanceTimersByTime(1);
+    expect(dispatch.mock.calls.length).toBe(1);
+  });
+
+  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;
+    });
+
+    expect(dispatch.mock.calls[1]).toMatchSnapshot();
+  });
+
+  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);
+    });
+  });
+
+  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 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()', () => {
+    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();
+    });
+  });
+
+  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 pollingSubscription = new PollingSubscription(
+        {
+          key: 'test.com',
+          schema: PollingArticleResource,
+          fetch,
+          frequency: 5000,
+          getState: () => initialState,
+        },
+        dispatch,
+        listener,
+      );
+      jest.advanceTimersByTime(1);
+      return { dispatch, fetch, pollingSubscription };
+    }
+
+    it('should not dispatch when offline', () => {
+      jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(false);
+      const listener = new DefaultConnectionListener();
+      const offlineSpy = jest.spyOn(listener, 'addOfflineListener');
+      const onlineSpy = jest.spyOn(listener, 'addOnlineListener');
+      const { dispatch } = createMocks(listener);
+      jest.advanceTimersByTime(50000);
+      jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(true);
+      expect(dispatch.mock.calls.length).toBe(0);
+      expect(offlineSpy.mock.calls.length).toBe(0);
+      expect(onlineSpy.mock.calls.length).toBe(1);
+    });
+
+    it('should not dispatch when onLine is undefined (default to true)', () => {
+      jest.spyOn(navigator, 'onLine', 'get').mockReturnValue(undefined as any);
+      const listener = new DefaultConnectionListener();
+      const offlineSpy = jest.spyOn(listener, 'addOfflineListener');
+      const onlineSpy = jest.spyOn(listener, 'addOnlineListener');
+      const { dispatch } = createMocks(listener);
+      expect(dispatch.mock.calls.length).toBe(1);
+      expect(offlineSpy.mock.calls.length).toBe(1);
+      expect(onlineSpy.mock.calls.length).toBe(0);
+    });
+
+    it('should immediately start fetching when online', () => {
+      const listener = new MockConnectionListener(false);
+      const { dispatch } = createMocks(listener);
+      expect(dispatch.mock.calls.length).toBe(0);
+
+      listener.trigger('online');
+      jest.advanceTimersByTime(1);
+      expect(dispatch.mock.calls.length).toBe(1);
+      jest.advanceTimersByTime(5000);
+      expect(dispatch.mock.calls.length).toBe(2);
+      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);
+      expect(dispatch.mock.calls.length).toBe(1);
+
+      listener.trigger('offline');
+      jest.advanceTimersByTime(50000);
+      expect(dispatch.mock.calls.length).toBe(1);
+      expect(listener.offlineHandlers.length).toBe(0);
+      expect(listener.onlineHandlers.length).toBe(1);
+    });
+  });
+});

package/src/manager/__tests__/subscriptionManager.ts

@@ -0,0 +1,208 @@
+import { Article, PollingArticleResource } from '__tests__/new';
+
+import { actionTypes, Controller, initialState } from '../..';
+import { legacyActions } from '../../types';
+import SubscriptionManager, { Subscription } from '../SubscriptionManager.js';
+
+type SubscribeAction = legacyActions.SubscribeAction;
+
+type UnsubscribeAction = legacyActions.UnsubscribeAction;
+
+const { UNSUBSCRIBE_TYPE, SUBSCRIBE_TYPE, RECEIVE_TYPE } = actionTypes;
+
+function onError(e: any) {
+  e.preventDefault();
+}
+beforeEach(() => {
+  if (typeof addEventListener === 'function')
+    addEventListener('error', onError);
+});
+afterEach(() => {
+  if (typeof removeEventListener === 'function')
+    removeEventListener('error', onError);
+});
+
+describe('SubscriptionManager', () => {
+  class TestSubscription implements Subscription {
+    add = jest.fn();
+    remove = jest.fn(() => true);
+    cleanup = jest.fn();
+  }
+  const manager = new SubscriptionManager(TestSubscription);
+  const getState = () => initialState;
+
+  describe('getMiddleware()', () => {
+    it('should return the same value every call', () => {
+      const a = manager.getMiddleware();
+      expect(a).toBe(manager.getMiddleware());
+      expect(a).toBe(manager.getMiddleware());
+    });
+  });
+
+  describe('cleanup()', () => {
+    it('should cleanup all Subcription members', () => {
+      const sub = new TestSubscription();
+      (manager as any).subscriptions[
+        PollingArticleResource.get.key({ id: 5 })
+      ] = sub;
+      manager.cleanup();
+      expect(sub.cleanup.mock.calls.length).toBe(1);
+    });
+  });
+
+  describe('middleware', () => {
+    function createSubscribeAction(
+      payload: Record<string, any>,
+      reject = false,
+    ): SubscribeAction {
+      const fetch = reject
+        ? () => Promise.reject(new Error('Failed'))
+        : () => Promise.resolve(payload);
+      return {
+        type: SUBSCRIBE_TYPE,
+        meta: {
+          schema: Article,
+          key: PollingArticleResource.get.key({ id: payload.id }),
+          fetch,
+          options: { pollFrequency: 1000 },
+        },
+      };
+    }
+    function createUnsubscribeAction(
+      payload: Record<string, any>,
+    ): UnsubscribeAction {
+      return {
+        type: UNSUBSCRIBE_TYPE,
+        meta: {
+          key: PollingArticleResource.get.key({ id: payload.id }),
+          options: { pollFrequency: 1000 },
+        },
+      };
+    }
+
+    const manager = new SubscriptionManager(TestSubscription);
+    const middleware = manager.getMiddleware();
+    const next = jest.fn();
+    const dispatch = () => Promise.resolve();
+    const controller = new Controller({ dispatch, getState });
+    const API: Controller & { controller: Controller } = Object.create(
+      controller,
+      {
+        controller: { value: controller },
+      },
+    );
+    it('subscribe should add a subscription', () => {
+      const action = createSubscribeAction({ id: 5 });
+      middleware(API)(next)(action);
+
+      expect(next).not.toHaveBeenCalled();
+      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+    });
+    it('subscribe should add a subscription (no frequency)', () => {
+      const action = createSubscribeAction({ id: 597 });
+      delete action.meta.options;
+      middleware(API)(next)(action);
+
+      expect(next).not.toHaveBeenCalled();
+      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+    });
+
+    it('subscribe with same should call subscription.add', () => {
+      const action = createSubscribeAction({ id: 5, title: 'four' });
+      middleware(API)(next)(action);
+
+      expect(
+        (manager as any).subscriptions[action.meta.key].add.mock.calls.length,
+      ).toBe(1);
+      middleware(API)(next)(action);
+      expect(
+        (manager as any).subscriptions[action.meta.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.meta.key].add.mock.calls.length,
+      ).toBe(0);
+    });
+    it('subscribe with another should not call previous', () => {
+      expect(
+        (manager as any).subscriptions[
+          PollingArticleResource.get.key({ id: 5 })
+        ].add.mock.calls.length,
+      ).toBe(2);
+    });
+
+    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(
+        () => true,
+      );
+
+      middleware(API)(next)(action);
+
+      expect((manager as any).subscriptions[action.meta.key]).not.toBeDefined();
+    });
+
+    it('unsubscribe should delete when remove returns true (no frequency)', () => {
+      middleware(API)(next)(
+        createSubscribeAction({ id: 50, title: 'four cakes' }),
+      );
+
+      const action = createUnsubscribeAction({ id: 50, title: 'four cakes' });
+      delete action.meta.options;
+      (manager as any).subscriptions[action.meta.key].remove.mockImplementation(
+        () => true,
+      );
+
+      middleware(API)(next)(action);
+
+      expect((manager as any).subscriptions[action.meta.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(
+        () => false,
+      );
+
+      middleware(API)(next)(action);
+
+      expect((manager as any).subscriptions[action.meta.key]).toBeDefined();
+      expect(
+        (manager as any).subscriptions[action.meta.key].remove.mock.calls
+          .length,
+      ).toBe(1);
+    });
+
+    it('unsubscribe should do nothing when there was no subscription already', () => {
+      const oldError = console.error;
+      const spy = (console.error = jest.fn());
+
+      const action = createUnsubscribeAction({ id: 25 });
+
+      middleware(API)(next)(action);
+
+      expect((manager as any).subscriptions[action.meta.key]).not.toBeDefined();
+
+      expect(spy.mock.calls[0]).toMatchInlineSnapshot(`
+        [
+          "Mismatched unsubscribe: GET http://test.com/article/25 is not subscribed",
+        ]
+      `);
+      console.error = oldError;
+    });
+
+    it('should let other actions pass through', () => {
+      const action = { type: RECEIVE_TYPE };
+      next.mockReset();
+
+      middleware(API)(next)(action as any);
+
+      expect(next.mock.calls.length).toBe(1);
+    });
+  });
+});

package/src/manager/applyManager.ts

@@ -0,0 +1,33 @@
+import type Controller from '../controller/Controller.js';
+import type { Reducer, Dispatch, ReducerState } from '../middlewareTypes.js';
+import { Manager } from '../types.js';
+
+export default function applyManager(
+  managers: Manager[],
+  controller: Controller,
+): Middleware[] {
+  return managers.map(manager => {
+    const middleware = manager.getMiddleware();
+    return ({ dispatch, getState }) => {
+      (controller as any).dispatch = dispatch;
+      (controller as any).getState = getState;
+      // this is needed for backwards compatibility as we added 'controller' prop previously
+      const API = Object.create(controller, {
+        controller: { value: controller },
+      });
+      // controller is a superset of the middleware API
+      return middleware(API);
+    };
+  });
+}
+
+/* These should be compatible with redux */
+export interface MiddlewareAPI<
+  R extends Reducer<any, any> = Reducer<any, any>,
+> {
+  getState: () => ReducerState<R>;
+  dispatch: Dispatch<R>;
+}
+export type Middleware = <R extends Reducer<any, any>>({
+  dispatch,
+}: MiddlewareAPI<R>) => (next: Dispatch<R>) => Dispatch<R>;