@data-client/core 0.2.1 → 0.4.0

package/src/controller/__tests__/Controller.ts

@@ -1,9 +1,11 @@
 import { Endpoint, Entity } from '@data-client/endpoint';
+import { normalize } from '@data-client/normalizr';
 import { CoolerArticleResource } from '__tests__/new';
+import { createEntityMeta } from '__tests__/utils';
 
 import { ExpiryStatus } from '../..';
 import { initialState } from '../../state/reducer/createReducer';
-import Contoller from '../Controller';
+import Controller from '../Controller';
 
 function ignoreError(e: Event) {
   e.preventDefault();
@@ -19,11 +21,83 @@ afterEach(() => {
 
 describe('Controller', () => {
   it('warns when dispatching during middleware setup', () => {
-    const controller = new Contoller();
+    const controller = new Controller();
     expect(() =>
       controller.fetch(CoolerArticleResource.get, { id: 5 }),
     ).toThrowErrorMatchingInlineSnapshot(
       `"Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch."`,
     );
   });
+
+  describe('fetchIfStale', () => {
+    it('should NOT fetch if result is NOT stale', () => {
+      const payload = {
+        id: 5,
+        title: 'hi ho',
+        content: 'whatever',
+        tags: ['a', 'best', 'react'],
+      };
+      const { entities, result } = normalize(
+        payload,
+        CoolerArticleResource.get.schema,
+      );
+      const fetchKey = CoolerArticleResource.get.key({ id: payload.id });
+      const state = {
+        ...initialState,
+        entities,
+        results: {
+          [fetchKey]: result,
+        },
+        entityMeta: createEntityMeta(entities),
+        meta: {
+          [fetchKey]: {
+            date: Date.now(),
+            expiresAt: Date.now() + 10000,
+          },
+        },
+      };
+      const getState = () => state;
+      const controller = new Controller({
+        dispatch: jest.fn(() => Promise.resolve()),
+        getState,
+      });
+      controller.fetchIfStale(CoolerArticleResource.get, { id: payload.id });
+      expect(controller.dispatch.mock.calls.length).toBe(0);
+    });
+    it('should fetch if result stale', () => {
+      const payload = {
+        id: 5,
+        title: 'hi ho',
+        content: 'whatever',
+        tags: ['a', 'best', 'react'],
+      };
+      const { entities, result } = normalize(
+        payload,
+        CoolerArticleResource.get.schema,
+      );
+      const fetchKey = CoolerArticleResource.get.key({ id: payload.id });
+      const state = {
+        ...initialState,
+        entities,
+        results: {
+          [fetchKey]: result,
+        },
+        entityMeta: createEntityMeta(entities),
+        meta: {
+          [fetchKey]: {
+            date: 0,
+            expiresAt: 0,
+          },
+        },
+      };
+      const getState = () => state;
+      const controller = new Controller({
+        dispatch: jest.fn(() => Promise.resolve()),
+        getState,
+      });
+      controller.fetchIfStale(CoolerArticleResource.get, { id: payload.id });
+
+      expect(controller.dispatch.mock.calls.length).toBe(1);
+    });
+  });
 });

package/src/controller/createExpireAll.ts

@@ -0,0 +1,11 @@
+import { EXPIREALL_TYPE } from '../actionTypes.js';
+import type { ExpireAllAction } from '../types.js';
+
+export default function createExpireAll(
+  testKey: (key: string) => boolean,
+): ExpireAllAction {
+  return {
+    type: EXPIREALL_TYPE,
+    testKey,
+  };
+}

package/src/newActions.ts

@@ -14,6 +14,7 @@ import type {
   GC_TYPE,
   OPTIMISTIC_TYPE,
   INVALIDATEALL_TYPE,
+  EXPIREALL_TYPE,
 } from './actionTypes.js';
 import type { EndpointUpdateFunction } from './controller/types.js';
 
@@ -112,6 +113,12 @@ export interface UnsubscribeAction<
   };
 }
 
+/* EXPIRY */
+export interface ExpireAllAction {
+  type: typeof EXPIREALL_TYPE;
+  testKey: (key: string) => boolean;
+}
+
 /* INVALIDATE */
 export interface InvalidateAllAction {
   type: typeof INVALIDATEALL_TYPE;
@@ -146,5 +153,6 @@ export type ActionTypes =
   | UnsubscribeAction
   | InvalidateAction
   | InvalidateAllAction
+  | ExpireAllAction
   | ResetAction
   | GCAction;

package/src/state/reducer/createReducer.ts

@@ -1,3 +1,4 @@
+import { expireReducer } from './expireReducer.js';
 import { fetchReducer } from './fetchReducer.js';
 import { invalidateReducer } from './invalidateReducer.js';
 import { setReducer } from './setReducer.js';
@@ -9,6 +10,7 @@ import {
   GC_TYPE,
   OPTIMISTIC_TYPE,
   INVALIDATEALL_TYPE,
+  EXPIREALL_TYPE,
 } from '../../actionTypes.js';
 import type Controller from '../../controller/Controller.js';
 import type { ActionTypes, State } from '../../types.js';
@@ -43,6 +45,9 @@ export default function createReducer(controller: Controller): ReducerType {
       case INVALIDATE_TYPE:
         return invalidateReducer(state, action);
 
+      case EXPIREALL_TYPE:
+        return expireReducer(state, action);
+
       case RESET_TYPE:
         return { ...initialState, lastReset: action.date };
 

package/src/state/reducer/expireReducer.ts

@@ -0,0 +1,20 @@
+import type { State, ExpireAllAction } from '../../types.js';
+
+export function expireReducer(state: State<unknown>, action: ExpireAllAction) {
+  const meta = { ...state.meta };
+
+  Object.keys(meta).forEach(key => {
+    if (action.testKey(key)) {
+      meta[key] = {
+        ...meta[key],
+        // 1 instead of 0 so we can do 'falsy' checks to see if it is set
+        expiresAt: 1,
+      };
+    }
+  });
+
+  return {
+    ...state,
+    meta,
+  };
+}

package/ts3.4/actionTypes.d.ts

@@ -8,5 +8,6 @@ export declare const SUBSCRIBE_TYPE: "rest-hooks/subscribe";
 export declare const UNSUBSCRIBE_TYPE: "rest-hook/unsubscribe";
 export declare const INVALIDATE_TYPE: "rest-hooks/invalidate";
 export declare const INVALIDATEALL_TYPE: "rest-hooks/invalidateall";
+export declare const EXPIREALL_TYPE: "rest-hooks/expireall";
 export declare const GC_TYPE: "rest-hooks/gc";
 //# sourceMappingURL=actionTypes.d.ts.map

package/ts3.4/controller/Controller.d.ts

@@ -38,6 +38,13 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
     }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+    /**
+     * Fetches only if endpoint is considered 'stale'; otherwise returns undefined
+     * @see https://dataclient.io/docs/api/Controller#fetchIfStale
+     */
+    fetchIfStale: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
+        update?: EndpointUpdateFunction<E> | undefined;
+    }>(endpoint: E, ...args_0: Parameters<E>) => (E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>) | undefined;
     /**
      * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
      * @see https://resthooks.io/docs/api/Controller#invalidate
@@ -50,10 +57,19 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
     /**
      * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
      * @see https://resthooks.io/docs/api/Controller#invalidateAll
+     * @returns Promise that resolves when invalidation is commited.
      */
     invalidateAll: (options: {
         testKey: (key: string) => boolean;
     }) => Promise<void>;
+    /**
+     * Sets all matching endpoint result keys to be STALE.
+     * @see https://dataclient.io/docs/api/Controller#expireAll
+     * @returns Promise that resolves when expiry is commited. *NOT* fetch promise
+     */
+    expireAll: (options: {
+        testKey: (key: string) => boolean;
+    }) => Promise<void>;
     /**
      * Resets the entire Rest Hooks cache. All inflight requests will not resolve.
      * @see https://resthooks.io/docs/api/Controller#resetEntireStore

package/ts3.4/controller/createExpireAll.d.ts

@@ -0,0 +1,3 @@
+import { ExpireAllAction } from '../types.js';
+export default function createExpireAll(testKey: (key: string) => boolean): ExpireAllAction;
+//# sourceMappingURL=createExpireAll.d.ts.map

package/ts3.4/newActions.d.ts

@@ -1,5 +1,5 @@
 import { EndpointInterface, ResolveType, UnknownError } from '@data-client/normalizr';
-import { SET_TYPE, RESET_TYPE, FETCH_TYPE, SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE, INVALIDATE_TYPE, GC_TYPE, OPTIMISTIC_TYPE, INVALIDATEALL_TYPE } from './actionTypes.js';
+import { SET_TYPE, RESET_TYPE, FETCH_TYPE, SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE, INVALIDATE_TYPE, GC_TYPE, OPTIMISTIC_TYPE, INVALIDATEALL_TYPE, EXPIREALL_TYPE } from './actionTypes.js';
 import { EndpointUpdateFunction } from './controller/types.js';
 type EndpointAndUpdate<E extends EndpointInterface> = EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
@@ -69,6 +69,10 @@ export interface UnsubscribeAction<E extends EndpointAndUpdate<E> = EndpointDefa
         key: string;
     };
 }
+export interface ExpireAllAction {
+    type: typeof EXPIREALL_TYPE;
+    testKey: (key: string) => boolean;
+}
 export interface InvalidateAllAction {
     type: typeof INVALIDATEALL_TYPE;
     testKey: (key: string) => boolean;
@@ -91,6 +95,6 @@ export interface GCAction {
     ][];
     results: string[];
 }
-export type ActionTypes = FetchAction | OptimisticAction | SetAction | SubscribeAction | UnsubscribeAction | InvalidateAction | InvalidateAllAction | ResetAction | GCAction;
+export type ActionTypes = FetchAction | OptimisticAction | SetAction | SubscribeAction | UnsubscribeAction | InvalidateAction | InvalidateAllAction | ExpireAllAction | ResetAction | GCAction;
 export {};
 //# sourceMappingURL=newActions.d.ts.map

package/ts3.4/state/reducer/expireReducer.d.ts

@@ -0,0 +1,36 @@
+import { State, ExpireAllAction } from '../../types.js';
+export declare function expireReducer(state: State<unknown>, action: ExpireAllAction): {
+    meta: {
+        [x: string]: {
+            readonly date: number;
+            readonly error?: import("packages/normalizr/lib/index.js").ErrorTypes | undefined;
+            readonly expiresAt: number;
+            readonly prevExpiresAt?: number | undefined;
+            readonly invalidated?: boolean | undefined;
+            readonly errorPolicy?: "hard" | "soft" | undefined;
+        };
+    };
+    entities: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: unknown;
+        } | undefined;
+    };
+    indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
+    results: {
+        readonly [key: string]: unknown;
+    };
+    entityMeta: {
+        readonly [entityKey: string]: {
+            readonly [pk: string]: {
+                readonly date: number;
+                readonly expiresAt: number;
+                readonly fetchedAt: number;
+            };
+        };
+    };
+    optimistic: (import("../../newActions.js").SetAction | import("../../newActions.js").OptimisticAction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined> & {
+        update?: import("../../index.js").EndpointUpdateFunction<import("packages/normalizr/lib/index.js").EndpointInterface<import("packages/normalizr/lib/index.js").FetchFunction, import("packages/normalizr/lib/interface.js").Schema | undefined, boolean | undefined>> | undefined;
+    }>)[];
+    lastReset: number;
+};
+//# sourceMappingURL=expireReducer.d.ts.map