@data-client/core 0.1.0 → 0.2.1

package/src/controller/createSubscription.ts

@@ -1,24 +1,18 @@
 import type { EndpointInterface } from '@data-client/normalizr';
 
 import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';
-import type {
-  CompatibleSubscribeAction,
-  CompatibleUnsubscribeAction,
-} from '../compatibleActions.js';
+import type { SubscribeAction, UnsubscribeAction } from '../types.js';
 
 export function createSubscription<E extends EndpointInterface>(
   endpoint: E,
   { args }: { args: readonly [...Parameters<E>] },
-): CompatibleSubscribeAction<E> {
+): SubscribeAction<E> {
   return {
     type: SUBSCRIBE_TYPE,
     endpoint,
     meta: {
       args,
       key: endpoint.key(...args),
-      fetch: () => endpoint(...args),
-      schema: endpoint.schema,
-      options: endpoint,
     },
   };
 }
@@ -26,14 +20,13 @@ export function createSubscription<E extends EndpointInterface>(
 export function createUnsubscription<E extends EndpointInterface>(
   endpoint: E,
   { args }: { args: readonly [...Parameters<E>] },
-): CompatibleUnsubscribeAction<E> {
+): UnsubscribeAction<E> {
   return {
     type: UNSUBSCRIBE_TYPE,
     endpoint,
     meta: {
       args,
       key: endpoint.key(...args),
-      options: endpoint,
     },
   };
 }

package/src/index.ts

@@ -30,32 +30,18 @@ export {
   default as createReducer,
   initialState,
 } from './state/reducer/createReducer.js';
-export { default as reducer } from './state/reducerInstance.js';
 export { default as applyManager } from './manager/applyManager.js';
 
 export { default as Controller } from './controller/Controller.js';
 export type {
-  CompatibleDispatch,
+  DataClientDispatch,
   GenericDispatch,
 } from './controller/Controller.js';
 export { default as createFetch } from './controller/createFetch.js';
-export { default as createReceive } from './controller/createReceive.js';
+export { default as createReceive } from './controller/createSet.js';
 
 export * from './controller/types.js';
-export * as legacyActions from './state/legacy-actions/index.js';
 export * as actionTypes from './actionTypes.js';
 /* istanbul ignore next */
 export * from './types.js';
-export type {
-  FetchShape,
-  ReadShape,
-  MutateShape,
-  DeleteShape,
-} from './endpoint/shapes.js';
-export type {
-  SetShapeParams,
-  ParamsFromShape,
-  BodyFromShape,
-  ReturnFromShape,
-} from './endpoint/types.js';
 export * from './manager/index.js';

package/src/internal.ts

@@ -1,3 +1,3 @@
-export { inferResults, DELETED } from '@data-client/normalizr';
+export { inferResults, DELETED, INVALID } from '@data-client/normalizr';
 export { default as RIC } from './state/RIC.js';
 export { initialState } from './state/reducer/createReducer.js';

package/src/manager/DevtoolsManager.ts

@@ -37,7 +37,7 @@ const DEFAULT_CONFIG = {
  *
  * Options: https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md
  *
- * @see https://resthooks.io/docs/api/DevToolsManager
+ * @see https://dataclient.io/docs/api/DevToolsManager
  */
 export default class DevToolsManager implements Manager {
   protected declare middleware: Middleware;

package/src/manager/LogoutManager.ts

@@ -1,14 +1,13 @@
 import { SET_TYPE } from '../actionTypes.js';
 import Controller from '../controller/Controller.js';
 import { UnknownError } from '../index.js';
-import type { CombinedActionTypes } from '../types.js';
-import { Manager } from '../types.js';
+import { ActionTypes, Manager } from '../types.js';
 
 /** Handling network unauthorized indicators like HTTP 401
  *
- * @see https://resthooks.io/docs/api/LogoutManager
+ * @see https://dataclient.io/docs/api/LogoutManager
  */
-export default class LogoutManager implements Manager<CombinedActionTypes> {
+export default class LogoutManager implements Manager {
   protected declare middleware: Middleware;
 
   constructor({ handleLogout, shouldLogout }: Props = {}) {
@@ -42,7 +41,7 @@ export default class LogoutManager implements Manager<CombinedActionTypes> {
   }
 }
 
-type Dispatch = (value: CombinedActionTypes) => Promise<void>;
+type Dispatch = (value: ActionTypes) => Promise<void>;
 
 // this further restricts the types to be future compatible
 export type Middleware = <C extends Controller<Dispatch>>(

package/src/manager/NetworkManager.ts

@@ -1,19 +1,14 @@
 import { SET_TYPE, FETCH_TYPE, RESET_TYPE } from '../actionTypes.js';
 import Controller from '../controller/Controller.js';
-import { initialState } from '../internal.js';
-import {
-  createReceive,
-  createReceiveError,
-} from '../state/legacy-actions/index.js';
+import createSet from '../controller/createSet.js';
 import RIC from '../state/RIC.js';
 import type {
   FetchAction,
-  ReceiveAction,
   Manager,
   ActionTypes,
   MiddlewareAPI,
   Middleware,
-  State,
+  SetAction,
 } from '../types.js';
 
 export class ResetError extends Error {
@@ -31,7 +26,7 @@ export class ResetError extends Error {
  *
  * Interfaces with store via a redux-compatible middleware.
  *
- * @see https://resthooks.io/docs/api/NetworkManager
+ * @see https://dataclient.io/docs/api/NetworkManager
  */
 export default class NetworkManager implements Manager {
   protected fetched: { [k: string]: Promise<any> } = Object.create(null);
@@ -41,7 +36,6 @@ export default class NetworkManager implements Manager {
   declare readonly dataExpiryLength: number;
   declare readonly errorExpiryLength: number;
   protected declare middleware: Middleware;
-  protected getState: () => State<unknown> = () => initialState;
   protected controller: Controller = new Controller();
   declare cleanupDate?: number;
 
@@ -49,25 +43,19 @@ export default class NetworkManager implements Manager {
     this.dataExpiryLength = dataExpiryLength;
     this.errorExpiryLength = errorExpiryLength;
 
-    this.middleware = <C extends MiddlewareAPI>({
-      dispatch,
-      getState,
-      controller,
-    }: C) => {
-      this.getState = getState;
+    this.middleware = <C extends MiddlewareAPI>(controller: C) => {
       this.controller = controller;
       return (next: C['dispatch']): C['dispatch'] =>
         (action): Promise<void> => {
           switch (action.type) {
             case FETCH_TYPE:
-              this.handleFetch(action, dispatch, controller);
+              this.handleFetch(action);
               // This is the only case that causes any state change
               // It's important to intercept other fetches as we don't want to trigger reducers during
               // render - so we need to stop 'readonly' fetches which can be triggered in render
               if (
-                action.meta.optimisticResponse !== undefined ||
-                (action.endpoint?.getOptimisticResponse !== undefined &&
-                  action.endpoint.sideEffect)
+                action.endpoint.getOptimisticResponse !== undefined &&
+                action.endpoint.sideEffect
               ) {
                 return next(action);
               }
@@ -81,8 +69,14 @@ export default class NetworkManager implements Manager {
                     controller.getState().meta[action.meta.key]?.error;
                   // processing errors result in state meta having error, so we should reject the promise
                   if (error) {
-                    // TODO: use only new action types
-                    this.handleReceive(createReceiveError(error, action.meta));
+                    this.handleReceive(
+                      createSet(action.endpoint, {
+                        args: action.meta.args as any,
+                        response: error,
+                        fetchedAt: action.meta.fetchedAt,
+                        error: true,
+                      }),
+                    );
                   } else {
                     this.handleReceive(action);
                   }
@@ -148,10 +142,7 @@ export default class NetworkManager implements Manager {
 
   protected getLastReset() {
     if (this.cleanupDate) return this.cleanupDate;
-    const lastReset = this.controller.getState().lastReset;
-    if (lastReset instanceof Date) return lastReset.valueOf();
-    if (typeof lastReset !== 'number') return -Infinity;
-    return lastReset;
+    return this.controller.getState().lastReset;
   }
 
   /** Called when middleware intercepts 'rest-hooks/fetch' action.
@@ -162,18 +153,9 @@ export default class NetworkManager implements Manager {
    * Uses throttle only when instructed by action meta. This is valuable
    * for ensures mutation requests always go through.
    */
-  protected handleFetch(
-    action: FetchAction,
-    dispatch: (action: any) => Promise<void>,
-    controller: Controller,
-  ) {
+  protected handleFetch(action: FetchAction) {
     const fetch = action.payload;
-    const { key, throttle, resolve, reject } = action.meta;
-    // TODO(breaking): remove support for Date type in 'Receive' action
-    const createdAt =
-      typeof action.meta.createdAt !== 'number'
-        ? action.meta.createdAt.getTime()
-        : action.meta.createdAt;
+    const { key, throttle, resolve, reject, createdAt } = action.meta;
 
     const deferedFetch = () => {
       let promise = fetch();
@@ -192,7 +174,7 @@ export default class NetworkManager implements Manager {
       // schedule non-throttled resolutions in a microtask before receive
       // this enables users awaiting their fetch to trigger any react updates needed to deal
       // with upcoming changes because of the fetch (for instance avoiding suspense if something is deleted)
-      if (!throttle && action.endpoint) {
+      if (!throttle) {
         promise = resolvePromise(promise);
       }
       promise = promise
@@ -209,26 +191,11 @@ export default class NetworkManager implements Manager {
 
           // don't update state with promises started before last clear
           if (createdAt >= lastReset) {
-            // we still check for controller in case someone didn't have type protection since this didn't always exist
-            if (action.endpoint && this.controller) {
-              this.controller.resolve(action.endpoint, {
-                args: action.meta.args as any,
-                response: data,
-                fetchedAt: createdAt,
-              });
-            } else {
-              // TODO(breaking): is this branch still possible? remove in next major update
-              // does this throw if the reducer fails? - no because reducer is wrapped in try/catch
-              this.controller.dispatch(
-                createReceive(data, {
-                  ...action.meta,
-                  fetchedAt: createdAt,
-                  dataExpiryLength:
-                    action.meta.options?.dataExpiryLength ??
-                    this.dataExpiryLength,
-                }),
-              );
-            }
+            this.controller.resolve(action.endpoint, {
+              args: action.meta.args as any,
+              response: data,
+              fetchedAt: createdAt,
+            });
           }
           return data;
         })
@@ -236,31 +203,15 @@ export default class NetworkManager implements Manager {
           const lastReset = this.getLastReset();
           // don't update state with promises started before last clear
           if (createdAt >= lastReset) {
-            if (action.endpoint && this.controller) {
-              this.controller.resolve(action.endpoint, {
-                args: action.meta.args as any,
-                response: error,
-                fetchedAt: createdAt,
-                error: true,
-              });
-            } else {
-              this.controller.dispatch(
-                createReceiveError(error, {
-                  ...action.meta,
-                  errorExpiryLength:
-                    action.meta.options?.errorExpiryLength ??
-                    this.errorExpiryLength,
-                  fetchedAt: createdAt,
-                }),
-              );
-            }
+            this.controller.resolve(action.endpoint, {
+              args: action.meta.args as any,
+              response: error,
+              fetchedAt: createdAt,
+              error: true,
+            });
           }
           throw error;
         });
-      // legacy behavior schedules resolution after dispatch
-      if (!throttle && !action.endpoint) {
-        promise = resolvePromise(promise);
-      }
       return promise;
     };
 
@@ -277,7 +228,7 @@ export default class NetworkManager implements Manager {
    *
    * Will resolve the promise associated with receive key.
    */
-  protected handleReceive(action: ReceiveAction) {
+  protected handleReceive(action: SetAction) {
     // this can still turn out to be untrue since this is async
     if (action.meta.key in this.fetched) {
       let promiseHandler: (value?: any) => void;

package/src/manager/PollingSubscription.ts

@@ -1,45 +1,43 @@
-import type { EndpointInterface, Schema } from '@data-client/normalizr';
+import type { EndpointInterface } from '@data-client/normalizr';
 
 import ConnectionListener from './ConnectionListener.js';
 import DefaultConnectionListener from './DefaultConnectionListener.js';
-import { Subscription, SubscriptionInit } from './SubscriptionManager.js';
-import createFetch from '../controller/createFetch.js';
-import type { State, Dispatch } from '../types.js';
+import type { Subscription } from './SubscriptionManager.js';
+import type Controller from '../controller/Controller.js';
+import type { SubscribeAction } from '../types.js';
 
 /**
  * PollingSubscription keeps a given resource updated by
  * dispatching a fetch at a rate equal to the minimum update
  * interval requested.
  *
- * @see https://resthooks.io/docs/api/PollingSubscription
+ * @see https://dataclient.io/docs/api/PollingSubscription
  */
 export default class PollingSubscription implements Subscription {
-  protected declare readonly schema: Schema | undefined;
-  protected declare readonly fetch: () => Promise<any>;
+  protected declare readonly endpoint: EndpointInterface;
+  protected declare readonly args: readonly any[];
   protected declare readonly key: string;
   protected declare frequency: number;
   protected frequencyHistogram: Map<number, number> = new Map();
-  protected declare dispatch: Dispatch<any>;
-  protected declare getState: () => State<unknown>;
+  protected declare controller: Controller;
   protected declare intervalId?: ReturnType<typeof setInterval>;
   protected declare lastIntervalId?: ReturnType<typeof setInterval>;
   protected declare startId?: ReturnType<typeof setTimeout>;
   private declare connectionListener: ConnectionListener;
 
   constructor(
-    { key, schema, fetch, frequency, getState }: SubscriptionInit,
-    dispatch: Dispatch<any>,
+    action: Omit<SubscribeAction, 'type'>,
+    controller: Controller,
     connectionListener?: ConnectionListener,
   ) {
-    if (frequency === undefined)
+    if (action.endpoint.pollFrequency === undefined)
       throw new Error('frequency needed for polling subscription');
-    this.schema = schema;
-    this.fetch = fetch;
-    this.frequency = frequency;
-    this.key = key;
+    this.endpoint = action.endpoint;
+    this.frequency = action.endpoint.pollFrequency;
+    this.args = action.meta.args;
+    this.key = action.meta.key;
     this.frequencyHistogram.set(this.frequency, 1);
-    this.dispatch = dispatch;
-    this.getState = getState;
+    this.controller = controller;
     this.connectionListener =
       connectionListener || new DefaultConnectionListener();
 
@@ -123,16 +121,17 @@ export default class PollingSubscription implements Subscription {
 
   /** Trigger request for latest resource */
   protected update() {
-    const endpoint: EndpointInterface = () => this.fetch();
-    (endpoint as any).schema = this.schema;
-    endpoint.key = () => this.key;
-    (endpoint as any).dataExpiryLength = this.frequency / 2;
-    (endpoint as any).errorExpiryLength = this.frequency / 10;
+    const sup = this.endpoint;
+    const endpoint = function (this: any, ...args: any[]) {
+      return sup.call(this, ...args);
+    };
+    Object.assign(endpoint, this.endpoint);
+    endpoint.dataExpiryLength = this.frequency / 2;
+    endpoint.errorExpiryLength = this.frequency / 10;
     endpoint.errorPolicy = () => 'soft' as const;
-    const action = createFetch(endpoint, { args: [] });
+    endpoint.key = () => this.key;
     // stop any errors here from bubbling
-    (action.meta.promise as Promise<any>).catch(e => null);
-    this.dispatch(action);
+    this.controller.fetch(endpoint, ...this.args).catch(() => null);
   }
 
   /** What happens when browser goes offline */
@@ -146,17 +145,20 @@ export default class PollingSubscription implements Subscription {
   protected onlineListener = () => {
     this.connectionListener.removeOnlineListener(this.onlineListener);
     const now = Date.now();
-    this.startId = setTimeout(() => {
-      if (this.startId) {
-        delete this.startId;
-        this.update();
-        this.run();
-      } else if (process.env.NODE_ENV !== 'production') {
-        console.warn(
-          `Poll setTimeout for ${this.key} still running, but timeoutId deleted`,
-        );
-      }
-    }, Math.max(0, this.lastFetchTime() - now + this.frequency));
+    this.startId = setTimeout(
+      () => {
+        if (this.startId) {
+          delete this.startId;
+          this.update();
+          this.run();
+        } else if (process.env.NODE_ENV !== 'production') {
+          console.warn(
+            `Poll setTimeout for ${this.key} still running, but timeoutId deleted`,
+          );
+        }
+      },
+      Math.max(0, this.lastFetchTime() - now + this.frequency),
+    );
     this.connectionListener.addOfflineListener(this.offlineListener);
   };
 
@@ -185,6 +187,6 @@ export default class PollingSubscription implements Subscription {
 
   /** Last fetch time */
   protected lastFetchTime() {
-    return this.getState().meta[this.key]?.date ?? 0;
+    return this.controller.getState().meta[this.key]?.date ?? 0;
   }
 }

package/src/manager/SubscriptionManager.ts

@@ -1,27 +1,15 @@
-import type { Schema } from '@data-client/normalizr';
-
 import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';
+import Controller from '../controller/Controller.js';
 import type {
   Manager,
-  State,
   MiddlewareAPI,
   Middleware,
-  Dispatch,
   UnsubscribeAction,
   SubscribeAction,
 } from '../types.js';
 
 type Actions = UnsubscribeAction | SubscribeAction;
 
-/** Properties sent to Subscription constructor */
-export interface SubscriptionInit {
-  schema?: Schema | undefined;
-  fetch: () => Promise<any>;
-  key: string;
-  getState: () => State<unknown>;
-  frequency?: number | undefined;
-}
-
 /** Interface handling a single resource subscription */
 export interface Subscription {
   add(frequency?: number): void;
@@ -31,7 +19,10 @@ export interface Subscription {
 
 /** The static class that constructs Subscription */
 export interface SubscriptionConstructable {
-  new (init: SubscriptionInit, dispatch: Dispatch<any>): Subscription;
+  new (
+    action: Omit<SubscribeAction, 'type'>,
+    controller: Controller,
+  ): Subscription;
 }
 
 /** Handles subscription actions -> fetch or receive actions
@@ -39,10 +30,10 @@ export interface SubscriptionConstructable {
  * Constructor takes a SubscriptionConstructable class to control how
  * subscriptions are handled. (e.g., polling, websockets)
  *
- * @see https://resthooks.io/docs/api/SubscriptionManager
+ * @see https://dataclient.io/docs/api/SubscriptionManager
  */
 export default class SubscriptionManager<S extends SubscriptionConstructable>
-  implements Manager
+  implements Manager<Actions>
 {
   protected subscriptions: {
     [key: string]: InstanceType<S>;
@@ -50,23 +41,25 @@ export default class SubscriptionManager<S extends SubscriptionConstructable>
 
   protected declare readonly Subscription: S;
   protected declare middleware: Middleware;
+  protected controller: Controller = new Controller();
 
   constructor(Subscription: S) {
     this.Subscription = Subscription;
 
-    this.middleware = <C extends MiddlewareAPI>({ dispatch, getState }: C) => {
+    this.middleware = <C extends MiddlewareAPI>(controller: C) => {
+      this.controller = controller;
       return (next: C['dispatch']): C['dispatch'] =>
         action => {
           switch (action.type) {
             case SUBSCRIBE_TYPE:
               try {
-                this.handleSubscribe(action, dispatch, getState);
+                this.handleSubscribe(action);
               } catch (e) {
                 console.error(e);
               }
               return Promise.resolve();
             case UNSUBSCRIBE_TYPE:
-              this.handleUnsubscribe(action, dispatch);
+              this.handleUnsubscribe(action);
               return Promise.resolve();
             default:
               return next(action);
@@ -85,38 +78,16 @@ export default class SubscriptionManager<S extends SubscriptionConstructable>
   /** Called when middleware intercepts 'rest-hooks/subscribe' action.
    *
    */
-  protected handleSubscribe(
-    action: SubscribeAction,
-    dispatch: (action: any) => Promise<void>,
-    getState: () => State<unknown>,
-  ) {
-    let options: SubscriptionInit;
-    if (action.endpoint) {
-      const { endpoint } = action;
-      const { args } = action.meta;
-      options = {
-        schema: endpoint.schema,
-        fetch: () => endpoint(...args),
-        frequency: endpoint.pollFrequency,
-        key: endpoint.key(...args),
-        getState,
-      };
-    } else {
-      options = {
-        key: action.meta.key,
-        frequency: action.meta.options?.pollFrequency,
-        schema: action.meta.schema,
-        fetch: action.meta.fetch,
-        getState,
-      };
-    }
+  protected handleSubscribe(action: SubscribeAction) {
+    const key = action.meta.key;
 
-    if (options.key in this.subscriptions) {
-      this.subscriptions[options.key].add(options.frequency);
+    if (key in this.subscriptions) {
+      const frequency = action.endpoint.pollFrequency;
+      this.subscriptions[key].add(frequency);
     } else {
-      this.subscriptions[options.key] = new this.Subscription(
-        options,
-        dispatch,
+      this.subscriptions[key] = new this.Subscription(
+        action,
+        this.controller,
       ) as InstanceType<S>;
     }
   }
@@ -124,15 +95,12 @@ export default class SubscriptionManager<S extends SubscriptionConstructable>
   /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
    *
    */
-  protected handleUnsubscribe(
-    action: UnsubscribeAction,
-    dispatch: (action: any) => Promise<void>,
-  ) {
+  protected handleUnsubscribe(action: UnsubscribeAction) {
     const key = action.meta.key;
-    const frequency = action.meta.options?.pollFrequency;
 
     /* istanbul ignore else */
     if (key in this.subscriptions) {
+      const frequency = action.endpoint.pollFrequency;
       const empty = this.subscriptions[key].remove(frequency);
       if (empty) {
         delete this.subscriptions[key];

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

@@ -1,19 +1,23 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`PollingSubscription should call after period 1`] = `
+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],
+      "nm": false,
       "promise": Promise {},
       "reject": [Function],
       "resolve": [Function],
-      "schema": [Function],
       "throttle": true,
-      "type": "read",
     },
     "payload": [Function],
     "type": "rest-hooks/fetch",
@@ -21,20 +25,18 @@ exports[`PollingSubscription should call after period 1`] = `
 ]
 `;
 
-exports[`PollingSubscription should call after period 2`] = `
+exports[`PollingSubscription fresh data should call after period 2`] = `
 [
   {
     "endpoint": [Function],
     "meta": {
       "args": [],
       "key": "test.com",
-      "options": [Function],
+      "nm": false,
       "promise": Promise {},
       "reject": [Function],
       "resolve": [Function],
-      "schema": [Function],
       "throttle": true,
-      "type": "read",
     },
     "payload": [Function],
     "type": "rest-hooks/fetch",