@data-client/core 0.1.0

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

@@ -0,0 +1,49 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`PollingSubscription fresh data cleanup() should not run even if interval not cancelled 1`] = `
+[
+  "Poll intervalId for test.com2 still running, but intervalId deleted",
+]
+`;
+
+exports[`PollingSubscription fresh data should call after period 1`] = `
+[
+  {
+    "endpoint": [Function],
+    "meta": {
+      "args": [],
+      "key": "test.com",
+      "options": [Function],
+      "promise": Promise {},
+      "reject": [Function],
+      "resolve": [Function],
+      "schema": [Function],
+      "throttle": true,
+      "type": "read",
+    },
+    "payload": [Function],
+    "type": "rest-hooks/fetch",
+  },
+]
+`;
+
+exports[`PollingSubscription fresh data should call after period 2`] = `
+[
+  {
+    "endpoint": [Function],
+    "meta": {
+      "args": [],
+      "key": "test.com",
+      "options": [Function],
+      "promise": Promise {},
+      "reject": [Function],
+      "resolve": [Function],
+      "schema": [Function],
+      "throttle": true,
+      "type": "read",
+    },
+    "payload": [Function],
+    "type": "rest-hooks/fetch",
+  },
+]
+`;

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

@@ -0,0 +1,43 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`PollingSubscription should call after period 1`] = `
+[
+  {
+    "endpoint": [Function],
+    "meta": {
+      "args": [],
+      "key": "test.com",
+      "options": [Function],
+      "promise": Promise {},
+      "reject": [Function],
+      "resolve": [Function],
+      "schema": [Function],
+      "throttle": true,
+      "type": "read",
+    },
+    "payload": [Function],
+    "type": "rest-hooks/fetch",
+  },
+]
+`;
+
+exports[`PollingSubscription should call after period 2`] = `
+[
+  {
+    "endpoint": [Function],
+    "meta": {
+      "args": [],
+      "key": "test.com",
+      "options": [Function],
+      "promise": Promise {},
+      "reject": [Function],
+      "resolve": [Function],
+      "schema": [Function],
+      "throttle": true,
+      "type": "read",
+    },
+    "payload": [Function],
+    "type": "rest-hooks/fetch",
+  },
+]
+`;

package/src/manager/__tests__/logoutManager.ts

@@ -0,0 +1,112 @@
+import { CoolerArticleResource } from '__tests__/new';
+
+import { Controller, initialState } from '../..';
+import { FETCH_TYPE, RESET_TYPE } from '../../actionTypes';
+import createReceive from '../../controller/createReceive';
+import LogoutManager from '../LogoutManager.js';
+
+function onError(e: any) {
+  e.preventDefault();
+}
+beforeEach(() => {
+  if (typeof addEventListener === 'function')
+    addEventListener('error', onError);
+});
+afterEach(() => {
+  if (typeof removeEventListener === 'function')
+    removeEventListener('error', onError);
+});
+
+describe('LogoutManager', () => {
+  const manager = new LogoutManager();
+  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('middleware', () => {
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+    const middleware = manager.getMiddleware();
+    const next = jest.fn();
+    const dispatch = jest.fn(action => Promise.resolve());
+    const controller = new Controller({ dispatch, getState });
+    const API: Controller & { controller: Controller } = Object.create(
+      controller,
+      {
+        controller: { value: controller },
+      },
+    );
+    it('should ignore non-error receive', async () => {
+      const action = createReceive(CoolerArticleResource.get, {
+        args: [{ id: 5 }],
+        response: { id: 5, title: 'hi' },
+      });
+      await middleware(API)(next)(action);
+
+      expect(dispatch.mock.calls.length).toBe(0);
+    });
+    it('should ignore non-401 receive', async () => {
+      const error: any = new Error('network failed');
+      error.status = 404;
+      const action = createReceive(CoolerArticleResource.get, {
+        args: [{ id: 5 }],
+        response: error,
+        error: true,
+      });
+      await middleware(API)(next)(action);
+
+      expect(dispatch.mock.calls.length).toBe(0);
+    });
+    it('should dispatch reset on 401', async () => {
+      jest.setSystemTime(0);
+      const error: any = new Error('network failed');
+      error.status = 401;
+      const action = createReceive(CoolerArticleResource.get, {
+        args: [{ id: 5 }],
+        response: error,
+        error: true,
+      });
+      await middleware(API)(next)(action);
+
+      expect(dispatch.mock.calls.length).toBe(1);
+      expect(dispatch.mock.calls[0][0]?.type).toBe(RESET_TYPE);
+    });
+
+    it('should call custom handleLogout', async () => {
+      const handleLogout = jest.fn((controller: Controller) => {});
+      const localMiddleware = new LogoutManager({
+        shouldLogout(error) {
+          return error.status === 403;
+        },
+        handleLogout,
+      }).getMiddleware();
+      jest.setSystemTime(0);
+      const error: any = new Error('network failed');
+      error.status = 403;
+      const action = createReceive(CoolerArticleResource.get, {
+        args: [{ id: 5 }],
+        response: error,
+        error: true,
+      });
+      await localMiddleware(API)(next)(action);
+
+      expect(handleLogout.mock.calls.length).toBe(1);
+    });
+
+    it('should let other actions pass through', async () => {
+      const action = { type: FETCH_TYPE };
+      next.mockReset();
+
+      await middleware(API)(next)(action as any);
+
+      expect(next.mock.calls.length).toBe(1);
+    });
+  });
+});

package/src/manager/__tests__/manager.ts

@@ -0,0 +1,44 @@
+import Controller from '../../controller/Controller';
+import { Middleware } from '../../middlewareTypes';
+import { CombinedActionTypes } from '../../types';
+import NetworkManager from '../NetworkManager';
+
+const middleware: Middleware = new NetworkManager().getMiddleware();
+it('middlewares should compose with non-rest-hooks middlewares', () => {
+  type AnotherAction = {
+    type: 'BOB';
+    payload: any;
+  };
+  const dispatch = jest.fn(
+    async (action: CombinedActionTypes | AnotherAction) => {},
+  );
+  const ctrl = new Controller({ dispatch });
+  const API: typeof ctrl & { controller: typeof ctrl } = Object.create(ctrl, {
+    controller: { value: ctrl },
+  });
+  type A = (typeof API)['dispatch'];
+  let counter = 0;
+  const nonRHMiddleware =
+    <
+      C extends {
+        dispatch: (action: AnotherAction) => Promise<void>;
+      },
+    >(
+      controller: C,
+    ) =>
+    (next: C['dispatch']): C['dispatch'] =>
+    async (action: AnotherAction) => {
+      next(action);
+      counter++;
+    };
+
+  const [a, b] = [middleware(API), nonRHMiddleware(API)];
+  const dispA = a(b(dispatch));
+  const dispB = b(a(dispatch));
+  expect(dispatch.mock.calls.length).toBe(0);
+  dispA({ type: 'BOB' as const, payload: 5 });
+  expect(dispatch.mock.calls.length).toBe(1);
+  dispB({ type: 'BOB' as const, payload: 5 });
+  expect(dispatch.mock.calls.length).toBe(2);
+  expect(counter).toBe(2);
+});

package/src/manager/__tests__/networkManager-legacy.ts

@@ -0,0 +1,394 @@
+import { ArticleResource } from '__tests__/legacy-3';
+
+import { RECEIVE_TYPE } from '../../actionTypes';
+import Controller from '../../controller/Controller';
+import { FetchAction } from '../../legacyActions';
+import { createFetch } from '../../state/legacy-actions';
+import { initialState } from '../../state/reducer/createReducer';
+import { Middleware } from '../../types';
+import NetworkManager from '../NetworkManager';
+
+describe('NetworkManager', () => {
+  const manager = new NetworkManager();
+  const getState = () => initialState;
+
+  afterAll(() => {
+    manager.cleanup();
+  });
+  let errorspy: jest.SpyInstance;
+  beforeEach(() => {
+    errorspy = jest.spyOn(global.console, 'error');
+  });
+  afterEach(() => {
+    errorspy.mockRestore();
+  });
+
+  it('getState() should have initialState before middleware run', () => {
+    class Hacked extends NetworkManager {
+      getHacked() {
+        return this.getState();
+      }
+    }
+    const hacked = new Hacked();
+    expect(hacked.getHacked()).toEqual(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());
+    });
+    it('should return the different value for a different instance', () => {
+      const a = manager.getMiddleware();
+      const manager2 = new NetworkManager();
+      const a2 = manager2.getMiddleware();
+      expect(a).not.toBe(a2);
+      expect(a2).toBe(manager2.getMiddleware());
+      manager2.cleanup();
+    });
+  });
+
+  describe('middleware', () => {
+    const detailShape = ArticleResource.detailShape();
+    detailShape.fetch = () => Promise.resolve({ id: 5, title: 'hi' });
+    const fetchResolveAction = createFetch(detailShape, {
+      params: { id: 5 },
+      throttle: false,
+    });
+
+    const updaters = {
+      [ArticleResource.listShape().getFetchKey({})]:
+        () => (result: string[], oldResults: string[] | undefined) =>
+          [...(oldResults || []), result] as any,
+    };
+    const fetchReceiveWithUpdatersAction: FetchAction = {
+      ...fetchResolveAction,
+      meta: {
+        ...fetchResolveAction.meta,
+        updaters,
+      },
+    };
+
+    const updateShape = ArticleResource.updateShape();
+    updateShape.fetch = (params, body) => Promise.resolve(body);
+    const fetchRpcWithUpdatersAction = createFetch(updateShape, {
+      params: { id: 5 },
+      body: { id: 5, title: 'hi' },
+      throttle: false,
+      updateParams: [
+        [
+          ArticleResource.listShape(),
+          {},
+          () => (result: string[], oldResults: string[] | undefined) =>
+            [...(oldResults || []), result],
+        ],
+      ],
+    });
+    const partialUpdateShape = ArticleResource.partialUpdateShape();
+    partialUpdateShape.fetch = (params, body) => Promise.resolve(body);
+    const fetchRpcWithUpdatersAndOptimisticAction = createFetch(
+      partialUpdateShape,
+      {
+        params: { id: 5 },
+        body: { id: 5, title: 'hi' },
+        throttle: false,
+        updateParams: [
+          [
+            ArticleResource.listShape(),
+            {},
+            () => (result: string[], oldResults: string[] | undefined) =>
+              [...(oldResults || []), result],
+          ],
+        ],
+      },
+    );
+
+    const errorUpdateShape = ArticleResource.updateShape();
+    errorUpdateShape.fetch = () => Promise.reject(new Error('Failed'));
+    const fetchRejectAction = createFetch(errorUpdateShape, {
+      params: { id: 5 },
+      body: { id: 5, title: 'hi' },
+      throttle: false,
+    });
+    (fetchRejectAction.meta.promise as any).catch(e => {});
+
+    let NM: NetworkManager;
+    let middleware: Middleware;
+    beforeEach(() => {
+      NM = new NetworkManager(42, 7);
+      middleware = NM.getMiddleware();
+    });
+    afterEach(() => {
+      NM.cleanup();
+    });
+
+    it('should handle fetch actions and dispatch on success', async () => {
+      const next = jest.fn();
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+
+      middleware(API)(next)(fetchResolveAction);
+
+      const data = await fetchResolveAction.payload();
+
+      const action = {
+        type: RECEIVE_TYPE,
+        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),
+          fetchedAt: expect.any(Number),
+        },
+      };
+      expect(dispatch).toHaveBeenCalledWith(action);
+      expect(next).not.toHaveBeenCalledWith(action);
+    });
+    it('should handle fetch receive action and dispatch on success with updaters', async () => {
+      const next = jest.fn();
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      middleware(API)(next)(fetchReceiveWithUpdatersAction);
+
+      const data = await fetchReceiveWithUpdatersAction.payload();
+
+      const action = {
+        type: RECEIVE_TYPE,
+        payload: data,
+        meta: {
+          updaters: {
+            [ArticleResource.listShape().getFetchKey({})]: expect.any(Function),
+          },
+          args: fetchReceiveWithUpdatersAction.meta.args,
+          update: fetchReceiveWithUpdatersAction.meta.update,
+          schema: fetchReceiveWithUpdatersAction.meta.schema,
+          key: fetchReceiveWithUpdatersAction.meta.key,
+          date: expect.any(Number),
+          expiresAt: expect.any(Number),
+          fetchedAt: expect.any(Number),
+        },
+      };
+      expect(dispatch).toHaveBeenCalledWith(action);
+      expect(next).not.toHaveBeenCalledWith(action);
+    });
+    it('should handle fetch rpc action and dispatch on success with updaters', async () => {
+      const next = jest.fn();
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      middleware(API)(next)(fetchRpcWithUpdatersAction);
+
+      const data = await fetchRpcWithUpdatersAction.payload();
+
+      const action = {
+        type: RECEIVE_TYPE,
+        payload: data,
+        meta: {
+          updaters: undefined,
+          args: fetchRpcWithUpdatersAction.meta.args,
+          update: expect.any(Function),
+          schema: fetchRpcWithUpdatersAction.meta.schema,
+          key: fetchRpcWithUpdatersAction.meta.key,
+          date: expect.any(Number),
+          expiresAt: expect.any(Number),
+          fetchedAt: expect.any(Number),
+        },
+      };
+      expect(dispatch).toHaveBeenCalledWith(action);
+      expect(next).not.toHaveBeenCalledWith(action);
+    });
+    it('should handle fetch rpc action with optimistic response and dispatch on success with updaters', async () => {
+      const next = jest.fn();
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      middleware(API)(next)(fetchRpcWithUpdatersAndOptimisticAction);
+
+      const data = await fetchRpcWithUpdatersAndOptimisticAction.payload();
+
+      expect(next).toHaveBeenCalled();
+      expect(dispatch).toHaveBeenCalledWith({
+        type: RECEIVE_TYPE,
+        payload: data,
+        meta: {
+          updaters: undefined,
+          args: fetchRpcWithUpdatersAndOptimisticAction.meta.args,
+          update: expect.any(Function),
+          schema: fetchRpcWithUpdatersAndOptimisticAction.meta.schema,
+          key: fetchRpcWithUpdatersAndOptimisticAction.meta.key,
+          date: expect.any(Number),
+          expiresAt: expect.any(Number),
+          fetchedAt: expect.any(Number),
+        },
+      });
+    });
+    it('should use dataExpireLength from action if specified', async () => {
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      middleware(API)(() => Promise.resolve())({
+        ...fetchResolveAction,
+        meta: {
+          ...fetchResolveAction.meta,
+          options: { dataExpiryLength: 314 },
+        },
+      });
+
+      await fetchResolveAction.payload();
+
+      expect(dispatch).toHaveBeenCalled();
+      const { meta } = dispatch.mock.calls[0][0];
+      expect(meta.expiresAt - meta.date).toBe(314);
+    });
+    it('should use dataExpireLength from NetworkManager if not specified in action', async () => {
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      middleware(API)(() => Promise.resolve())({
+        ...fetchResolveAction,
+        meta: {
+          ...fetchResolveAction.meta,
+          options: { dataExpiryLength: undefined },
+        },
+      });
+
+      await fetchResolveAction.payload();
+
+      expect(dispatch).toHaveBeenCalled();
+      const { meta } = dispatch.mock.calls[0][0];
+      expect(meta.expiresAt - meta.date).toBe(42);
+    });
+    it('should handle fetch actions and dispatch on error', async () => {
+      const next = jest.fn();
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      try {
+        await middleware(API)(next)(fetchRejectAction);
+      } catch (error) {
+        expect(next).not.toHaveBeenCalled();
+        expect(dispatch).toHaveBeenCalledWith({
+          type: RECEIVE_TYPE,
+          payload: error,
+          meta: {
+            schema: fetchRejectAction.meta.schema,
+            key: fetchRejectAction.meta.key,
+            date: expect.any(Number),
+            expiresAt: expect.any(Number),
+          },
+          error: true,
+        });
+      }
+    });
+    it('should use errorExpireLength from action if specified', async () => {
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      try {
+        await middleware(API)(() => Promise.resolve())({
+          ...fetchRejectAction,
+          meta: {
+            ...fetchRejectAction.meta,
+            options: { errorExpiryLength: 1234 },
+          },
+        });
+      } catch (error) {
+        expect(dispatch).toHaveBeenCalled();
+        const { meta } = dispatch.mock.calls[0][0];
+        expect(meta.expiresAt - meta.date).toBe(1234);
+      }
+    });
+    it('should use errorExpireLength from NetworkManager if not specified in action', async () => {
+      const dispatch = jest.fn();
+      const controller = new Controller({ dispatch, getState });
+      const API: Controller & { controller: Controller } = Object.create(
+        controller,
+        {
+          controller: { value: controller },
+        },
+      );
+      try {
+        await middleware(API)(() => Promise.resolve())({
+          ...fetchRejectAction,
+          meta: {
+            ...fetchRejectAction.meta,
+            options: {
+              ...fetchRejectAction.meta.options,
+              errorExpiryLength: undefined,
+            },
+          },
+        });
+      } catch (error) {
+        expect(dispatch).toHaveBeenCalled();
+        const { meta } = dispatch.mock.calls[0][0];
+        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());
+    });
+  });
+});