@data-client/core 0.1.0

package/src/state/applyUpdatersToResults.ts

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

package/src/state/legacy-actions/createFetch.ts

@@ -0,0 +1,95 @@
+// TODO(breaking): remove file - not used
+import { Schema } from '@data-client/normalizr';
+
+import { FETCH_TYPE } from '../../actionTypes.js';
+import {
+  FetchShape,
+  SchemaFromShape,
+  ParamsFromShape,
+  BodyFromShape,
+  OptimisticUpdateParams,
+} from '../../endpoint/index.js';
+import { FetchAction } from '../../legacyActions.js';
+
+interface Options<
+  Shape extends FetchShape<
+    Schema | undefined,
+    Readonly<object>,
+    Readonly<object | string> | void
+  >,
+> {
+  params: ParamsFromShape<Shape>;
+  body?: BodyFromShape<Shape>;
+  throttle: boolean;
+  updateParams?:
+    | OptimisticUpdateParams<
+        SchemaFromShape<Shape>,
+        FetchShape<Schema | undefined, any, any>
+      >[]
+    | undefined;
+}
+
+/** Requesting a fetch to begin
+ *
+ * @param fetchShape
+ * @param param1 { params, body, throttle, updateParams }
+ */
+export default function createFetch<
+  Shape extends FetchShape<
+    Schema | undefined,
+    Readonly<object>,
+    Readonly<object | string> | void
+  >,
+>(
+  fetchShape: Shape & {
+    update?: (...args: any) => Record<string, (...args: any) => any>;
+  },
+  { params, body, throttle, updateParams }: Options<Shape>,
+): FetchAction {
+  const { schema, type, getFetchKey, options } = fetchShape;
+
+  const key = getFetchKey(params);
+  let resolve: (value?: any | PromiseLike<any>) => void = 0 as any;
+  let reject: (reason?: any) => void = 0 as any;
+  const promise = new Promise<any>((a, b) => {
+    [resolve, reject] = [a, b];
+  });
+  const meta: FetchAction['meta'] = {
+    schema,
+    type,
+    args: [params, body],
+    key,
+    throttle,
+    options,
+    resolve,
+    reject,
+    promise,
+    createdAt: Date.now(),
+  };
+
+  if (fetchShape.update) {
+    meta.update = fetchShape.update;
+  }
+
+  // for simplicity we simply override if updateParams are defined - usage together is silly to support as we are migrating
+  if (updateParams) {
+    meta.update = (newresult: any): Record<string, (...args: any) => any> => {
+      const updateMap: any = {};
+      updateParams.forEach(([toShape, toParams, updateFn]) => {
+        updateMap[toShape.getFetchKey(toParams)] = (existing: any) =>
+          updateFn(newresult, existing);
+      });
+      return updateMap;
+    };
+  }
+
+  if (options?.optimisticUpdate) {
+    meta.optimisticResponse = options.optimisticUpdate(params, body);
+  }
+
+  return {
+    type: FETCH_TYPE,
+    payload: () => fetchShape.fetch(params, body),
+    meta,
+  };
+}

package/src/state/legacy-actions/createReceive.ts

@@ -0,0 +1,68 @@
+import type {
+  Schema,
+  EndpointExtraOptions as FetchOptions,
+} from '@data-client/normalizr';
+
+import { RECEIVE_TYPE } from '../../actionTypes.js';
+import { FetchAction, ReceiveAction } from '../../legacyActions.js';
+
+interface Options<
+  Payload extends object | string | number | null =
+    | object
+    | string
+    | number
+    | null,
+  S extends Schema | undefined = any,
+> extends Pick<
+    FetchAction<Payload, S>['meta'],
+    'schema' | 'key' | 'type' | 'updaters' | 'update' | 'args'
+  > {
+  dataExpiryLength: NonNullable<FetchOptions['dataExpiryLength']>;
+  fetchedAt?: number;
+}
+
+/** Update state with data
+ *
+ * @param data
+ * @param param1 { schema, key, type, updaters, dataExpiryLength }
+ */
+export default function createReceive<
+  Payload extends object | string | number | null =
+    | object
+    | string
+    | number
+    | null,
+  S extends Schema | undefined = any,
+>(
+  data: Payload,
+  {
+    schema,
+    key,
+    args,
+    updaters,
+    fetchedAt = 0,
+    update,
+    dataExpiryLength,
+  }: Options<Payload, S>,
+): ReceiveAction<Payload, S> {
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && dataExpiryLength < 0) {
+    throw new Error('Negative dataExpiryLength are not allowed.');
+  }
+  const now = Date.now();
+  const meta: ReceiveAction['meta'] = {
+    schema,
+    key,
+    args,
+    date: now,
+    fetchedAt,
+    expiresAt: now + dataExpiryLength,
+  };
+  meta.updaters = updaters;
+  meta.update = update;
+  return {
+    type: RECEIVE_TYPE,
+    payload: data,
+    meta,
+  };
+}

package/src/state/legacy-actions/createReceiveError.ts

@@ -0,0 +1,43 @@
+import {
+  Schema,
+  EndpointExtraOptions as FetchOptions,
+} from '@data-client/normalizr';
+
+import { RECEIVE_TYPE } from '../../actionTypes.js';
+import { FetchAction, ReceiveAction } from '../../legacyActions.js';
+
+interface Options<S extends Schema | undefined = any>
+  extends Pick<FetchAction<any, S>['meta'], 'schema' | 'key' | 'options'> {
+  errorExpiryLength?: NonNullable<FetchOptions['errorExpiryLength']>;
+  fetchedAt?: number;
+}
+
+export default function createReceiveError<S extends Schema | undefined = any>(
+  error: Error,
+  {
+    schema,
+    key,
+    options,
+    errorExpiryLength = 60000,
+    fetchedAt = 0,
+  }: Options<S>,
+): ReceiveAction {
+  /* istanbul ignore next */
+  if (process.env.NODE_ENV === 'development' && errorExpiryLength < 0) {
+    throw new Error('Negative errorExpiryLength are not allowed.');
+  }
+  const now = Date.now();
+  return {
+    type: RECEIVE_TYPE,
+    payload: error,
+    meta: {
+      schema,
+      key,
+      date: now,
+      fetchedAt,
+      expiresAt: now + errorExpiryLength,
+      errorPolicy: options?.errorPolicy,
+    },
+    error: true,
+  };
+}

package/src/state/legacy-actions/index.ts

@@ -0,0 +1,3 @@
+export { default as createFetch } from './createFetch.js';
+export { default as createReceive } from './createReceive.js';
+export { default as createReceiveError } from './createReceiveError.js';

package/src/state/reducer/createReducer.ts

@@ -0,0 +1,80 @@
+import { fetchReducer } from './fetchReducer.js';
+import { invalidateReducer } from './invalidateReducer.js';
+import { setReducer } from './setReducer.js';
+import {
+  SET_TYPE,
+  INVALIDATE_TYPE,
+  RESET_TYPE,
+  FETCH_TYPE,
+  GC_TYPE,
+  OPTIMISTIC_TYPE,
+  INVALIDATEALL_TYPE,
+} from '../../actionTypes.js';
+import type Controller from '../../controller/Controller.js';
+import type { OldActionTypes, ActionTypes, State } from '../../types.js';
+
+export default function createReducer(controller: Controller): ReducerType {
+  return function reducer(
+    state: State<unknown> | undefined,
+    action: OldActionTypes,
+  ): State<unknown> {
+    if (!state) state = initialState;
+    switch (action.type) {
+      case GC_TYPE:
+        // inline deletes are fine as these should have 0 refcounts
+        action.entities.forEach(([key, pk]) => {
+          delete (state as any).entities[key]?.[pk];
+          delete (state as any).entityMeta[key]?.[pk];
+        });
+        action.results.forEach(fetchKey => {
+          delete (state as any).results[fetchKey];
+          delete (state as any).meta[fetchKey];
+        });
+        return state;
+      case FETCH_TYPE:
+        return fetchReducer(state, action);
+
+      case OPTIMISTIC_TYPE:
+      // eslint-disable-next-line no-fallthrough
+      case SET_TYPE:
+        return setReducer(state, action, controller);
+
+      case INVALIDATEALL_TYPE:
+      case INVALIDATE_TYPE:
+        return invalidateReducer(state, action);
+
+      case RESET_TYPE:
+        if (
+          process.env.NODE_ENV !== 'production' &&
+          action.date === undefined
+        ) {
+          console.warn(
+            `${RESET_TYPE} sent without 'date' member. This is deprecated. Please use createReset() action creator to ensure correct action shape.`,
+          );
+        }
+        return { ...initialState, lastReset: action.date ?? Date.now() };
+
+      default:
+        // A reducer must always return a valid state.
+        // Alternatively you can throw an error if an invalid action is dispatched.
+        return state;
+    }
+  } as any;
+}
+
+export const initialState: State<unknown> = {
+  entities: {},
+  indexes: {},
+  results: {},
+  meta: {},
+  entityMeta: {},
+  optimistic: [],
+  lastReset: 0,
+};
+
+type ReducerType = (
+  state: State<unknown> | undefined,
+  action: ActionTypes,
+) => State<unknown>;
+
+type Writable<T> = { [P in keyof T]: NonNullable<Writable<T[P]>> };

package/src/state/reducer/fetchReducer.ts

@@ -0,0 +1,48 @@
+import createOptimistic from '../../controller/createOptimistic.js';
+import type {
+  ReceiveAction,
+  OptimisticAction,
+  FetchAction,
+} from '../../previousActions.js';
+import type { State } from '../../types.js';
+import { createReceive as legacyCreateReceive } from '../legacy-actions/index.js';
+
+export function fetchReducer(state: State<unknown>, action: FetchAction) {
+  const optimisticResponse = action.meta.optimisticResponse;
+  const getOptimisticResponse = action.endpoint?.getOptimisticResponse;
+  let receiveAction: ReceiveAction | OptimisticAction;
+
+  if (getOptimisticResponse && action.endpoint && action.endpoint.sideEffect) {
+    receiveAction = createOptimistic(action.endpoint, {
+      args: action.meta.args as readonly any[],
+      fetchedAt:
+        typeof action.meta.createdAt !== 'number'
+          ? action.meta.createdAt.getTime()
+          : action.meta.createdAt,
+    }) as any;
+  } /* istanbul ignore if */ else if (optimisticResponse) {
+    // TODO(breaking): this is no longer used, remove this branch
+    /* istanbul ignore next */
+    receiveAction = legacyCreateReceive(optimisticResponse, {
+      ...action.meta,
+      dataExpiryLength: Infinity,
+    });
+  } else {
+    // If 'fetch' action reaches the reducer there are no middlewares installed to handle it
+    /* istanbul ignore next */
+    if (process.env.NODE_ENV !== 'production') {
+      console.warn(
+        'Fetch appears unhandled - you are likely missing the NetworkManager middleware',
+      );
+      console.warn(
+        'See https://resthooks.io/docs/guides/redux#indextsx for hooking up redux',
+      );
+    }
+
+    return state;
+  }
+  return {
+    ...state,
+    optimistic: [...state.optimistic, receiveAction],
+  };
+}

package/src/state/reducer/invalidateReducer.ts

@@ -0,0 +1,39 @@
+import { INVALIDATE_TYPE } from '../../actionTypes.js';
+import type {
+  InvalidateAllAction,
+  InvalidateAction,
+} from '../../previousActions.js';
+import type { State } from '../../types.js';
+
+export function invalidateReducer(
+  state: State<unknown>,
+  action: InvalidateAction | InvalidateAllAction,
+) {
+  const results = { ...state.results };
+  const meta = { ...state.meta };
+  const invalidateKey = (key: string) => {
+    delete results[key];
+    const itemMeta = {
+      ...meta[key],
+      expiresAt: 0,
+      invalidated: true,
+    };
+    delete itemMeta.error;
+    meta[key] = itemMeta;
+  };
+  if (action.type === INVALIDATE_TYPE) {
+    invalidateKey(action.meta.key);
+  } else {
+    Object.keys(results).forEach(key => {
+      if (action.testKey(key)) {
+        invalidateKey(key);
+      }
+    });
+  }
+
+  return {
+    ...state,
+    results,
+    meta,
+  };
+}

package/src/state/reducer/setReducer.ts

@@ -0,0 +1,157 @@
+import { normalize } from '@data-client/normalizr';
+
+import { OPTIMISTIC_TYPE } from '../../actionTypes.js';
+import type Controller from '../../controller/Controller.js';
+import type { ReceiveAction, OptimisticAction } from '../../previousActions.js';
+import type { State } from '../../types.js';
+import applyUpdatersToResults from '../applyUpdatersToResults.js';
+
+export function setReducer(
+  state: State<unknown>,
+  action: OptimisticAction | ReceiveAction,
+  controller: Controller,
+) {
+  if (action.error) {
+    return reduceError(state, action, action.payload);
+  }
+  try {
+    let payload: any;
+    // for true receives payload is contained in action
+    if (action.type === OPTIMISTIC_TYPE) {
+      if (!action.endpoint.getOptimisticResponse) return state;
+      try {
+        // compute optimistic response based on current state
+        payload = action.endpoint.getOptimisticResponse.call(
+          action.endpoint,
+          controller.snapshot(state, action.meta.fetchedAt),
+          // if endpoint exists, so must args; TODO: fix typing
+          ...(action.meta.args as any[]),
+        );
+      } catch (e: any) {
+        // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
+        if (e.constructor?.name === 'AbortOptimistic') {
+          return state;
+        }
+        throw e;
+      }
+    } else {
+      payload = action.payload;
+    }
+    const { result, entities, indexes, entityMeta } = normalize(
+      payload,
+      action.meta.schema,
+      action.meta.args as any,
+      state.entities,
+      state.indexes,
+      state.entityMeta,
+      { fetchedAt: action.meta.date, ...action.meta },
+    );
+    let results = {
+      ...state.results,
+      [action.meta.key]: result,
+    };
+    try {
+      if ('updaters' in action.meta && action.meta.updaters) {
+        results = applyUpdatersToResults(
+          results,
+          result,
+          action.meta.updaters as any,
+        );
+      }
+      if (action.meta.update) {
+        const updaters = action.meta.update(
+          result,
+          ...(action.meta.args || []),
+        );
+        Object.keys(updaters).forEach(key => {
+          results[key] = updaters[key](results[key]);
+        });
+      }
+      // no reason to completely fail because of user-code error
+      // integrity of this state update is still guaranteed
+    } catch (error) {
+      console.error(
+        `The following error occured during Endpoint.update() for ${action.meta.key}`,
+      );
+      console.error(error);
+    }
+    return {
+      entities,
+      indexes,
+      results,
+      entityMeta,
+      meta: {
+        ...state.meta,
+        [action.meta.key]: {
+          date: action.meta.date,
+          expiresAt: action.meta.expiresAt,
+          prevExpiresAt: state.meta[action.meta.key]?.expiresAt,
+        },
+      },
+      optimistic: filterOptimistic(state, action),
+      lastReset: state.lastReset,
+    };
+    // reducer must update the state, so in case of processing errors we simply compute the results inline
+  } catch (error: any) {
+    if (typeof error === 'object') {
+      error.message = `Error processing ${
+        action.meta.key
+      }\n\nFull Schema: ${JSON.stringify(
+        action.meta.schema,
+        undefined,
+        2,
+      )}\n\nError:\n${error.message}`;
+      if ('payload' in action) error.payload = action.payload;
+      error.status = 400;
+    }
+
+    // this is not always bubbled up, so let's double sure this doesn't fail silently
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+      console.error(error);
+    }
+    return reduceError(state, action, error);
+  }
+}
+
+function reduceError(
+  state: State<unknown>,
+  action: ReceiveAction | OptimisticAction,
+  error: any,
+): State<unknown> {
+  if (error.name === 'AbortError') {
+    // In case we abort simply undo the optimistic update and act like no fetch even occured
+    // We still want those watching promises from fetch directly to observed the abort, but we don't want to
+    // Trigger errors in this case. This means theoretically improperly built abortes useResource() could suspend forever.
+    return {
+      ...state,
+      optimistic: filterOptimistic(state, action),
+    };
+  }
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      [action.meta.key]: {
+        date: action.meta.date,
+        error,
+        expiresAt: action.meta.expiresAt,
+        errorPolicy: action.meta.errorPolicy?.(error),
+      },
+    },
+    optimistic: filterOptimistic(state, action),
+  };
+}
+/** Filter all requests with same serialization that did not start after the resolving request */
+function filterOptimistic(
+  state: State<unknown>,
+  resolvingAction: ReceiveAction | OptimisticAction,
+) {
+  return state.optimistic.filter(
+    optimisticAction =>
+      optimisticAction.meta.key !== resolvingAction.meta.key ||
+      (optimisticAction.type === OPTIMISTIC_TYPE
+        ? optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt
+        : optimisticAction.meta.date > resolvingAction.meta.date),
+  );
+}

package/src/state/reducerInstance.ts

@@ -0,0 +1,14 @@
+/* istanbul ignore file */
+import createReducer from './reducer/createReducer.js';
+import Controller from '../controller/Controller.js';
+import { ActionTypes, State } from '../types.js';
+
+/**
+ * @deprecated use createReducer instead
+ */
+const reducer: (
+  state: State<unknown> | undefined,
+  action: ActionTypes,
+) => State<unknown> = createReducer(new Controller());
+
+export default reducer;

package/src/state/selectMeta.ts

@@ -0,0 +1,8 @@
+import type { State } from '../types.js';
+
+export default function selectMeta<R = any>(
+  state: State<R>,
+  fetchKey: string,
+): State<R>['meta'][string] {
+  return state.meta[fetchKey];
+}