@data-client/core 0.1.0 → 0.2.0

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

@@ -1,423 +0,0 @@
-import { Article, PollingArticleResource } from '__tests__/new';
-
-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 = [];
-  }
-}
-
-const makeState = (key: string, time: number) => () => ({
-  ...initialState,
-  meta: { [key]: { date: time, expiresAt: Infinity } },
-});
-
-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 a = () => Promise.resolve({ id: 5, title: 'hi' });
-  const fetch = jest.fn(a);
-
-  describe('existing data', () => {
-    it('should wait to call for fresh data', () => {
-      const dispatch = jest.fn();
-      jest.useFakeTimers();
-      const sub2 = new PollingSubscription(
-        {
-          key: 'test.com',
-          schema: Article,
-          fetch,
-          frequency: 5000,
-          getState: makeState('test.com', Date.now()),
-        },
-        dispatch,
-      );
-      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();
-    });
-
-    it('should only run once with multiple simultaneous starts', () => {
-      const dispatch = jest.fn();
-      jest.useFakeTimers();
-      const sub2 = new PollingSubscription(
-        {
-          key: 'test.com',
-          schema: Article,
-          fetch,
-          frequency: 5000,
-          getState: () => initialState,
-        },
-        dispatch,
-      );
-      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();
-    });
-  });
-
-  describe('fresh data', () => {
-    const dispatch = jest.fn();
-    let sub: PollingSubscription;
-
-    beforeAll(() => {
-      jest.useFakeTimers();
-      sub = new PollingSubscription(
-        {
-          key: 'test.com',
-          schema: Article,
-          fetch,
-          frequency: 5000,
-          getState: makeState('test.com', 0),
-        },
-        dispatch,
-      );
-    });
-    afterAll(() => {
-      sub.cleanup();
-      jest.useRealTimers();
-    });
-
-    it('should throw on undefined frequency in construction', () => {
-      expect(
-        () =>
-          new PollingSubscription(
-            {
-              key: 'test.com',
-              schema: Article,
-              fetch,
-              getState: makeState('test.com', 0),
-            },
-            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: Article,
-            fetch,
-            frequency: 5000,
-            getState: makeState('test.com', 0),
-          },
-          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', () => {
-        sub.cleanup();
-        sub = new PollingSubscription(
-          {
-            key: 'test.com2',
-            schema: Article,
-            fetch,
-            frequency: 5000,
-            getState: makeState('test.com', 0),
-          },
-          dispatch,
-        );
-        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('offline support', () => {
-    beforeAll(() => {
-      jest.useFakeTimers();
-    });
-    afterAll(() => {
-      jest.useRealTimers();
-    });
-
-    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: Article,
-          fetch,
-          frequency: 5000,
-          getState: makeState('test.com', 0),
-        },
-        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 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);
-      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/next/Controller.ts

@@ -1,39 +0,0 @@
-import type { EndpointInterface, Denormalize } from '@data-client/normalizr';
-import { denormalize } from '@data-client/normalizr';
-
-import BaseController, {
-  CompatibleDispatch,
-  GenericDispatch,
-} from '../controller/BaseController.js';
-import createFetch from '../controller/createFetch.js';
-import type { EndpointUpdateFunction } from '../controller/types.js';
-
-export default class Controller<
-  D extends GenericDispatch = CompatibleDispatch,
-> extends BaseController<D> {
-  /**
-   * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
-   * @see https://resthooks.io/docs/api/Controller#fetch
-   */
-  fetch = <
-    E extends EndpointInterface & { update?: EndpointUpdateFunction<E> },
-  >(
-    endpoint: E,
-    ...args: readonly [...Parameters<E>]
-  ): E['schema'] extends undefined | null
-    ? ReturnType<E>
-    : Promise<Denormalize<E['schema']>> => {
-    const action = createFetch(endpoint, {
-      args,
-    });
-    this.dispatch(action);
-
-    if (endpoint.schema) {
-      return action.meta.promise.then(input =>
-        denormalize(input, endpoint.schema, {}, args),
-      ) as any;
-    }
-    return action.meta.promise as any;
-  };
-}
-export * from '../controller/BaseController.js';

package/src/previousActions.ts

@@ -1,159 +0,0 @@
-import {
-  EndpointExtraOptions,
-  EndpointInterface,
-  Schema,
-} from '@data-client/normalizr';
-import type { UpdateFunction } from '@data-client/normalizr';
-import { FSAWithMeta, FSAWithPayloadAndMeta } from 'flux-standard-action';
-
-import {
-  FETCH_TYPE,
-  GC_TYPE,
-  INVALIDATE_TYPE,
-  OPTIMISTIC_TYPE,
-  RECEIVE_TYPE,
-  RESET_TYPE,
-  SUBSCRIBE_TYPE,
-  UNSUBSCRIBE_TYPE,
-} from './actionTypes.js';
-import { EndpointUpdateFunction } from './controller/types.js';
-import { FetchShape } from './endpoint/index.js';
-import { ErrorableFSAWithPayloadAndMeta } from './fsa.js';
-import type { InvalidateAction, InvalidateAllAction } from './newActions.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>
-> & { endpoint?: EndpointInterface };
-
-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?: EndpointInterface;
-}
-
-export interface SubscribeAction
-  extends FSAWithMeta<typeof SUBSCRIBE_TYPE, undefined, any> {
-  endpoint?: EndpointInterface;
-  meta: {
-    args?: readonly any[];
-    schema: Schema | undefined;
-    fetch: () => Promise<any>;
-    key: string;
-    options: EndpointExtraOptions | undefined;
-  };
-}
-
-export interface UnsubscribeAction
-  extends FSAWithMeta<typeof UNSUBSCRIBE_TYPE, undefined, any> {
-  endpoint?: EndpointInterface;
-  meta: {
-    args?: readonly any[];
-    key: string;
-    options: EndpointExtraOptions | undefined;
-  };
-}
-
-export type { InvalidateAction, InvalidateAllAction };
-
-export interface GCAction {
-  type: typeof GC_TYPE;
-  entities: [string, string][];
-  results: string[];
-}
-
-export type ActionTypes =
-  | FetchAction
-  | OptimisticAction
-  | ReceiveAction
-  | SubscribeAction
-  | UnsubscribeAction
-  | InvalidateAction
-  | InvalidateAllAction
-  | ResetAction
-  | GCAction;

package/src/state/__tests__/applyUpdatersToResults.ts

@@ -1,40 +0,0 @@
-import { ArticleResourceWithOtherListUrl } from '__tests__/new';
-
-import applyUpdatersToResults from '../applyUpdatersToResults';
-
-describe('applyUpdatersToResults', () => {
-  const results = {
-    [ArticleResourceWithOtherListUrl.getList.key({})]: ['1', '2'],
-  };
-
-  it('handles a single updater', () => {
-    const newResults = applyUpdatersToResults(results, '3', {
-      [ArticleResourceWithOtherListUrl.getList.key({})]: (
-        article: string,
-        articles: string[] | undefined,
-      ) => [article, ...(articles || [])],
-    });
-    expect(newResults).toStrictEqual({
-      ...results,
-      [ArticleResourceWithOtherListUrl.getList.key({})]: ['3', '1', '2'],
-    });
-  });
-
-  it('handles multiple updaters sequentially', () => {
-    const newResults = applyUpdatersToResults(results, '3', {
-      [ArticleResourceWithOtherListUrl.getList.key({})]: (
-        article: string,
-        articles: string[] | undefined,
-      ) => [article, ...(articles || [])],
-      [ArticleResourceWithOtherListUrl.otherList.key({})]: (
-        article: string,
-        articles: string[] | undefined,
-      ) => [...(articles || []), article],
-    });
-    expect(newResults).toStrictEqual({
-      ...results,
-      [ArticleResourceWithOtherListUrl.getList.key({})]: ['3', '1', '2'],
-      [ArticleResourceWithOtherListUrl.otherList.key({})]: ['3'],
-    });
-  });
-});

package/src/state/applyUpdatersToResults.ts

@@ -1,29 +0,0 @@
-import type { Schema, Normalize, UpdateFunction } from '@data-client/normalizr';
-
-type ResultStateFromUpdateFunctions<
-  SourceSchema extends Schema,
-  UpdateFunctions extends {
-    [key: string]: UpdateFunction<SourceSchema, any>;
-  },
-> = { [K in keyof UpdateFunctions]: any };
-
-export default function applyUpdatersToResults<
-  SourceSchema extends Schema,
-  UpdateFunctions extends {
-    [key: string]: UpdateFunction<SourceSchema, any>;
-  },
->(
-  results: ResultStateFromUpdateFunctions<SourceSchema, UpdateFunctions>,
-  result: Normalize<SourceSchema>,
-  updaters: UpdateFunctions,
-) {
-  return {
-    ...results,
-    ...Object.fromEntries(
-      Object.entries(updaters).map(([fetchKey, updater]) => [
-        fetchKey,
-        updater(result, results[fetchKey]),
-      ]),
-    ),
-  };
-}