@data-client/core 0.1.0 → 0.2.1

package/src/legacyActions.ts

@@ -1,163 +0,0 @@
-import type {
-  UpdateFunction,
-  Schema,
-  EndpointExtraOptions,
-  EndpointInterface,
-} from '@data-client/normalizr';
-import { FSAWithPayloadAndMeta, FSAWithMeta } from 'flux-standard-action';
-
-import {
-  RECEIVE_TYPE,
-  RESET_TYPE,
-  FETCH_TYPE,
-  SUBSCRIBE_TYPE,
-  UNSUBSCRIBE_TYPE,
-  INVALIDATE_TYPE,
-  GC_TYPE,
-  OPTIMISTIC_TYPE,
-} from './actionTypes.js';
-import type { EndpointUpdateFunction } from './controller/types.js';
-import { FetchShape } from './endpoint/index.js';
-import { ErrorableFSAWithPayloadAndMeta } from './fsa.js';
-
-export interface ReceiveMeta<S extends Schema | undefined> {
-  schema?: S;
-  key: string;
-  args?: readonly any[];
-  updaters?: Record<string, UpdateFunction<S, any>>;
-  update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
-  fetchedAt?: number;
-  date: number;
-  expiresAt: number;
-  errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
-}
-
-export type ReceiveAction<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
-> = ErrorableFSAWithPayloadAndMeta<
-  typeof RECEIVE_TYPE,
-  Payload,
-  ReceiveMeta<S>
->;
-
-export type OptimisticAction<
-  E extends EndpointInterface & {
-    update?: EndpointUpdateFunction<E>;
-  } = EndpointInterface & {
-    update?: EndpointUpdateFunction<EndpointInterface>;
-  },
-> = {
-  type: typeof OPTIMISTIC_TYPE;
-  meta: {
-    schema: E['schema'];
-    key: string;
-    args: readonly any[];
-    update?: (
-      result: any,
-      ...args: any
-    ) => Record<string, (...args: any) => any>;
-    fetchedAt: number;
-    date: number;
-    expiresAt: number;
-    errorPolicy?: (error: any) => 'hard' | 'soft' | undefined;
-  };
-  endpoint: E;
-  error?: undefined;
-};
-
-export interface ResetAction {
-  type: typeof RESET_TYPE;
-  date: number | Date;
-}
-
-interface FetchMeta<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
-> {
-  type: FetchShape<any, any>['type'];
-  schema?: S;
-  key: string;
-  args?: readonly any[];
-  updaters?: Record<string, UpdateFunction<S, any>>;
-  update?: (result: any, ...args: any) => Record<string, (...args: any) => any>;
-  options?: EndpointExtraOptions;
-  throttle: boolean;
-  resolve: (value?: any | PromiseLike<any>) => void;
-  reject: (reason?: any) => void;
-  promise: PromiseLike<any>;
-  createdAt: number | Date;
-  optimisticResponse?: Payload;
-  // indicates whether network manager processed it
-  nm?: boolean;
-}
-
-export interface FetchAction<
-  Payload extends object | string | number | null =
-    | object
-    | string
-    | number
-    | null,
-  S extends Schema | undefined = any,
-> extends FSAWithPayloadAndMeta<
-    typeof FETCH_TYPE,
-    () => Promise<Payload>,
-    FetchMeta<any, any>
-  > {
-  meta: FetchMeta<Payload, S>;
-  endpoint?: undefined;
-}
-
-export interface SubscribeAction
-  extends FSAWithMeta<typeof SUBSCRIBE_TYPE, undefined, any> {
-  meta: {
-    args?: readonly any[];
-    schema: Schema | undefined;
-    fetch: () => Promise<any>;
-    key: string;
-    options: EndpointExtraOptions | undefined;
-  };
-  endpoint?: undefined;
-}
-
-export interface UnsubscribeAction
-  extends FSAWithMeta<typeof UNSUBSCRIBE_TYPE, undefined, any> {
-  meta: {
-    args?: readonly any[];
-    key: string;
-    options: EndpointExtraOptions | undefined;
-  };
-  endpoint?: undefined;
-}
-
-export interface InvalidateAction
-  extends FSAWithMeta<typeof INVALIDATE_TYPE, undefined, any> {
-  meta: {
-    key: string;
-  };
-}
-
-export interface GCAction {
-  type: typeof GC_TYPE;
-  entities: [string, string][];
-  results: string[];
-}
-
-// put other actions here in union
-export type ActionTypes =
-  | FetchAction
-  | OptimisticAction
-  | ReceiveAction
-  | SubscribeAction
-  | UnsubscribeAction
-  | InvalidateAction
-  | ResetAction
-  | GCAction;

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

@@ -1,49 +0,0 @@
-// 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__/networkManager-legacy.ts

@@ -1,394 +0,0 @@
-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());
-    });
-  });
-});