@data-client/core 0.1.0

package/src/manager/devtoolsTypes.ts

@@ -0,0 +1,210 @@
+type Action = any;
+type ActionCreator<T> = any;
+
+// taken from https://github.com/reduxjs/redux-devtools/blob/main/packages/redux-devtools-extension/src/index.ts
+
+export interface EnhancerOptions {
+  /**
+   * the instance name to be showed on the monitor page. Default value is `document.title`.
+   * If not specified and there's no document title, it will consist of `tabId` and `instanceId`.
+   */
+  name?: string;
+  /**
+   * action creators functions to be available in the Dispatcher.
+   */
+  actionCreators?: ActionCreator<any>[] | { [key: string]: ActionCreator<any> };
+  /**
+   * if more than one action is dispatched in the indicated interval, all new actions will be collected and sent at once.
+   * It is the joint between performance and speed. When set to `0`, all actions will be sent instantly.
+   * Set it to a higher value when experiencing perf issues (also `maxAge` to a lower value).
+   *
+   * @default 500 ms.
+   */
+  latency?: number;
+  /**
+   * (> 1) - maximum allowed actions to be stored in the history tree. The oldest actions are removed once maxAge is reached. It's critical for performance.
+   *
+   * @default 50
+   */
+  maxAge?: number;
+  /**
+   * Customizes how actions and state are serialized and deserialized. Can be a boolean or object. If given a boolean, the behavior is the same as if you
+   * were to pass an object and specify `options` as a boolean. Giving an object allows fine-grained customization using the `replacer` and `reviver`
+   * functions.
+   */
+  serialize?:
+    | boolean
+    | {
+        /**
+         * - `undefined` - will use regular `JSON.stringify` to send data (it's the fast mode).
+         * - `false` - will handle also circular references.
+         * - `true` - will handle also date, regex, undefined, error objects, symbols, maps, sets and functions.
+         * - object, which contains `date`, `regex`, `undefined`, `error`, `symbol`, `map`, `set` and `function` keys.
+         *   For each of them you can indicate if to include (by setting as `true`).
+         *   For `function` key you can also specify a custom function which handles serialization.
+         *   See [`jsan`](https://github.com/kolodny/jsan) for more details.
+         */
+        options?:
+          | undefined
+          | boolean
+          | {
+              date?: true;
+              regex?: true;
+              undefined?: true;
+              error?: true;
+              symbol?: true;
+              map?: true;
+              set?: true;
+              function?: true | ((fn: (...args: any[]) => any) => string);
+            };
+        /**
+         * [JSON replacer function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#The_replacer_parameter) used for both actions and states stringify.
+         * In addition, you can specify a data type by adding a [`__serializedType__`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/helpers/index.js#L4)
+         * key. So you can deserialize it back while importing or persisting data.
+         * Moreover, it will also [show a nice preview showing the provided custom type](https://cloud.githubusercontent.com/assets/7957859/21814330/a17d556a-d761-11e6-85ef-159dd12f36c5.png):
+         */
+        replacer?: (key: string, value: unknown) => any;
+        /**
+         * [JSON `reviver` function](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Using_the_reviver_parameter)
+         * used for parsing the imported actions and states. See [`remotedev-serialize`](https://github.com/zalmoxisus/remotedev-serialize/blob/master/immutable/serialize.js#L8-L41)
+         * as an example on how to serialize special data types and get them back.
+         */
+        reviver?: (key: string, value: unknown) => any;
+      };
+  /**
+   * function which takes `action` object and id number as arguments, and should return `action` object back.
+   */
+  actionSanitizer?: <A extends Action>(action: A, id: number) => A;
+  /**
+   * function which takes `state` object and index as arguments, and should return `state` object back.
+   */
+  stateSanitizer?: <S>(state: S, index: number) => S;
+  /**
+   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+   * If `actionsWhitelist` specified, `actionsBlacklist` is ignored.
+   * @deprecated Use actionsDenylist instead.
+   */
+  actionsBlacklist?: string | string[];
+  /**
+   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+   * If `actionsWhitelist` specified, `actionsBlacklist` is ignored.
+   * @deprecated Use actionsAllowlist instead.
+   */
+  actionsWhitelist?: string | string[];
+  /**
+   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+   * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+   */
+  actionsDenylist?: string | string[];
+  /**
+   * *string or array of strings as regex* - actions types to be hidden / shown in the monitors (while passed to the reducers).
+   * If `actionsAllowlist` specified, `actionsDenylist` is ignored.
+   */
+  actionsAllowlist?: string | string[];
+  /**
+   * called for every action before sending, takes `state` and `action` object, and returns `true` in case it allows sending the current data to the monitor.
+   * Use it as a more advanced version of `actionsDenylist`/`actionsAllowlist` parameters.
+   */
+  predicate?: <S, A extends Action>(state: S, action: A) => boolean;
+  /**
+   * if specified as `false`, it will not record the changes till clicking on `Start recording` button.
+   * Available only for Redux enhancer, for others use `autoPause`.
+   *
+   * @default true
+   */
+  shouldRecordChanges?: boolean;
+  /**
+   * if specified, whenever clicking on `Pause recording` button and there are actions in the history log, will add this action type.
+   * If not specified, will commit when paused. Available only for Redux enhancer.
+   *
+   * @default "@@PAUSED""
+   */
+  pauseActionType?: string;
+  /**
+   * auto pauses when the extension’s window is not opened, and so has zero impact on your app when not in use.
+   * Not available for Redux enhancer (as it already does it but storing the data to be sent).
+   *
+   * @default false
+   */
+  autoPause?: boolean;
+  /**
+   * if specified as `true`, it will not allow any non-monitor actions to be dispatched till clicking on `Unlock changes` button.
+   * Available only for Redux enhancer.
+   *
+   * @default false
+   */
+  shouldStartLocked?: boolean;
+  /**
+   * if set to `false`, will not recompute the states on hot reloading (or on replacing the reducers). Available only for Redux enhancer.
+   *
+   * @default true
+   */
+  shouldHotReload?: boolean;
+  /**
+   * if specified as `true`, whenever there's an exception in reducers, the monitors will show the error message, and next actions will not be dispatched.
+   *
+   * @default false
+   */
+  shouldCatchErrors?: boolean;
+  /**
+   * If you want to restrict the extension, specify the features you allow.
+   * If not specified, all of the features are enabled. When set as an object, only those included as `true` will be allowed.
+   * Note that except `true`/`false`, `import` and `export` can be set as `custom` (which is by default for Redux enhancer), meaning that the importing/exporting occurs on the client side.
+   * Otherwise, you'll get/set the data right from the monitor part.
+   */
+  features?: {
+    /**
+     * start/pause recording of dispatched actions
+     */
+    pause?: boolean;
+    /**
+     * lock/unlock dispatching actions and side effects
+     */
+    lock?: boolean;
+    /**
+     * persist states on page reloading
+     */
+    persist?: boolean;
+    /**
+     * export history of actions in a file
+     */
+    export?: boolean | 'custom';
+    /**
+     * import history of actions from a file
+     */
+    import?: boolean | 'custom';
+    /**
+     * jump back and forth (time travelling)
+     */
+    jump?: boolean;
+    /**
+     * skip (cancel) actions
+     */
+    skip?: boolean;
+    /**
+     * drag and drop actions in the history list
+     */
+    reorder?: boolean;
+    /**
+     * dispatch custom actions or action creators
+     */
+    dispatch?: boolean;
+    /**
+     * generate tests for the selected actions
+     */
+    test?: boolean;
+  };
+  /**
+   * Set to true or a stacktrace-returning function to record call stack traces for dispatched actions.
+   * Defaults to false.
+   */
+  trace?: boolean | (<A extends Action>(action: A) => string);
+  /**
+   * The maximum number of stack trace entries to record per action. Defaults to 10.
+   */
+  traceLimit?: number;
+}
+
+export interface DevToolsConfig extends EnhancerOptions {
+  type?: string;
+}

package/src/manager/index.ts

@@ -0,0 +1,7 @@
+export type { default as ConnectionListener } from './ConnectionListener.js';
+export { default as DefaultConnectionListener } from './DefaultConnectionListener.js';
+export { default as PollingSubscription } from './PollingSubscription.js';
+export { default as SubscriptionManager } from './SubscriptionManager.js';
+export { default as DevToolsManager } from './DevtoolsManager.js';
+export { default as LogoutManager } from './LogoutManager.js';
+export type { DevToolsConfig } from './DevtoolsManager.js';

package/src/middlewareTypes.ts

@@ -0,0 +1,49 @@
+import type Controller from './controller/Controller.js';
+//import type { ActionTypes as LegacyActionTypes } from './legacyActions.js';
+import type { ActionTypes } from './newActions.js';
+import {
+  ActionTypes as LegacyActionTypes,
+  CombinedActionTypes,
+  State,
+} from './types.js';
+
+type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
+
+export interface MiddlewareAPI<R extends RestHooksReducer = RestHooksReducer>
+  extends Controller<RHDispatch<CombinedActionTypes>> {
+  controller: Controller<RHDispatch<CombinedActionTypes>>;
+}
+export interface MiddlewareController<Actions = LegacyActionTypes>
+  extends Controller<RHDispatch<Actions>> {
+  controller: Controller<RHDispatch<Actions>>;
+}
+
+export type Middleware<Actions = any> = <
+  C extends MiddlewareController<Actions>,
+>(
+  controller: C,
+) => (next: C['dispatch']) => C['dispatch'];
+
+export type RestHooksReducer = (
+  prevState: State<unknown>,
+  action: ActionTypes,
+) => State<unknown>;
+
+/* The next are types from React; but we don't want dependencies on it */
+export type Dispatch<R extends Reducer<any, any>> = (
+  action: ReducerAction<R>,
+) => Promise<void>;
+
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export type ReducerState<R extends Reducer<any, any>> = R extends Reducer<
+  infer S,
+  any
+>
+  ? S
+  : never;
+export type ReducerAction<R extends Reducer<any, any>> = R extends Reducer<
+  any,
+  infer A
+>
+  ? A
+  : never;

package/src/newActions.ts

@@ -0,0 +1,140 @@
+import type {
+  EndpointInterface,
+  ResolveType,
+  UnknownError,
+} from '@data-client/normalizr';
+
+import type {
+  SET_TYPE,
+  RESET_TYPE,
+  FETCH_TYPE,
+  SUBSCRIBE_TYPE,
+  UNSUBSCRIBE_TYPE,
+  INVALIDATE_TYPE,
+  GC_TYPE,
+  OPTIMISTIC_TYPE,
+  INVALIDATEALL_TYPE,
+} from './actionTypes.js';
+import type { EndpointUpdateFunction } from './controller/types.js';
+
+/* RECEIVE */
+export interface ReceiveMeta {
+  args: readonly any[];
+  fetchedAt: number;
+  date: number;
+  expiresAt: number;
+}
+export interface ReceiveActionSuccess<
+  E extends EndpointInterface = EndpointInterface,
+> {
+  type: typeof SET_TYPE;
+  endpoint: E;
+  meta: ReceiveMeta;
+  payload: ResolveType<E>;
+  error?: false;
+}
+export interface ReceiveActionError<
+  E extends EndpointInterface = EndpointInterface,
+> {
+  type: typeof SET_TYPE;
+  endpoint: E;
+  meta: ReceiveMeta;
+  payload: UnknownError;
+  error: true;
+}
+export type ReceiveAction<E extends EndpointInterface = EndpointInterface> =
+  | ReceiveActionSuccess<E>
+  | ReceiveActionError<E>;
+
+export type SetAction<E extends EndpointInterface = EndpointInterface> =
+  ReceiveAction<E>;
+
+/* FETCH */
+export interface FetchMeta {
+  args: readonly any[];
+  throttle: boolean;
+  resolve: (value?: any | PromiseLike<any>) => void;
+  reject: (reason?: any) => void;
+  promise: PromiseLike<any>;
+  createdAt: number;
+  // indicates whether network manager processed it
+  nm?: boolean;
+}
+
+export interface FetchAction<E extends EndpointInterface = EndpointInterface> {
+  type: typeof FETCH_TYPE;
+  endpoint: E;
+  meta: FetchMeta;
+  payload: () => ReturnType<E>;
+}
+
+/* OPTIMISTIC */
+export interface OptimisticAction<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  } = EndpointInterface & {
+    update?: EndpointUpdateFunction<EndpointInterface>;
+  },
+> {
+  type: typeof OPTIMISTIC_TYPE;
+  endpoint: E;
+  meta: ReceiveMeta;
+  error?: boolean;
+}
+
+/* SUBSCRIBE */
+export interface SubscribeAction<
+  E extends EndpointInterface = EndpointInterface,
+> {
+  type: typeof SUBSCRIBE_TYPE;
+  endpoint: E;
+  meta: {
+    args: readonly any[];
+  };
+}
+
+export interface UnsubscribeAction<
+  E extends EndpointInterface = EndpointInterface,
+> {
+  type: typeof UNSUBSCRIBE_TYPE;
+  endpoint: E;
+  meta: {
+    args: readonly any[];
+  };
+}
+
+/* INVALIDATE */
+export interface InvalidateAllAction {
+  type: typeof INVALIDATEALL_TYPE;
+  testKey: (key: string) => boolean;
+}
+
+export interface InvalidateAction {
+  type: typeof INVALIDATE_TYPE;
+  meta: {
+    key: string;
+  };
+}
+
+/* RESET */
+export interface ResetAction {
+  type: typeof RESET_TYPE;
+  date: number;
+}
+
+/* GC */
+export interface GCAction {
+  type: typeof GC_TYPE;
+  entities: [string, string][];
+  results: string[];
+}
+
+export type ActionTypes =
+  | FetchAction
+  | OptimisticAction
+  | ReceiveAction
+  | SubscribeAction
+  | UnsubscribeAction
+  | InvalidateAction
+  | ResetAction
+  | GCAction;

package/src/next/Controller.ts

@@ -0,0 +1,39 @@
+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/next/index.ts

@@ -0,0 +1,2 @@
+export { default as Controller } from './Controller.js';
+export * from './Controller.js';

package/src/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/src/previousActions.ts

@@ -0,0 +1,159 @@
+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/RIC.d.ts

@@ -0,0 +1,2 @@
+declare const RIC: (cb: (...args: any[]) => void, options: any) => void;
+export default RIC;

package/src/state/RIC.js

@@ -0,0 +1,5 @@
+const RIC =
+  typeof requestIdleCallback === 'function'
+    ? requestIdleCallback
+    : cb => setTimeout(cb, 0);
+export default RIC;

package/src/state/__tests__/RIC.web.ts

@@ -0,0 +1,16 @@
+describe('RequestIdleCallback', () => {
+  it('should still run when requestIdleCallback is not available', () => {
+    const requestIdle = (global as any).requestIdleCallback;
+    (global as any).requestIdleCallback = undefined;
+    jest.resetModules();
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const RIC = require('../RIC').default;
+    const fn = jest.fn();
+    jest.useFakeTimers();
+    RIC(fn, {});
+    jest.runAllTimers();
+    expect(fn).toBeCalled();
+    (global as any).requestIdleCallback = requestIdle;
+    jest.useRealTimers();
+  });
+});

package/src/state/__tests__/__snapshots__/reducer.ts.snap

@@ -0,0 +1,56 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`reducer should set error in meta for "receive" 1`] = `
+{
+  "entities": {},
+  "entityMeta": {},
+  "indexes": {},
+  "lastReset": 0,
+  "meta": {
+    "GET http://test.com/article/20": {
+      "date": 5000000000,
+      "error": [Error: hi],
+      "errorPolicy": undefined,
+      "expiresAt": 5000500000,
+    },
+  },
+  "optimistic": [],
+  "results": {},
+}
+`;
+
+exports[`reducer singles should update state correctly 1`] = `
+{
+  "entities": {
+    "Article": {
+      "20": {
+        "content": "this is the content",
+        "id": 20,
+        "title": "hi",
+      },
+    },
+  },
+  "entityMeta": {
+    "Article": {
+      "20": {
+        "date": 5000000000,
+        "expiresAt": 5000500000,
+        "fetchedAt": 5000000000,
+      },
+    },
+  },
+  "indexes": {},
+  "lastReset": 0,
+  "meta": {
+    "http://test.com/article/20": {
+      "date": 5000000000,
+      "expiresAt": 5000500000,
+      "prevExpiresAt": undefined,
+    },
+  },
+  "optimistic": [],
+  "results": {
+    "http://test.com/article/20": "20",
+  },
+}
+`;