@data-client/core 0.14.16 → 0.14.19

package/src/manager/initManager.ts

@@ -0,0 +1,21 @@
+import type Controller from '../controller/Controller.js';
+import { Manager, State } from '../types.js';
+
+export default function initManager(
+  managers: Manager[],
+  controller: Controller,
+  initialState: State<unknown>,
+) {
+  return () => {
+    managers.forEach(manager => {
+      manager.init?.(initialState);
+    });
+    controller.gcPolicy.init(controller);
+    return () => {
+      managers.forEach(manager => {
+        manager.cleanup();
+      });
+      controller.gcPolicy.cleanup();
+    };
+  };
+}

package/src/state/GCPolicy.ts

@@ -0,0 +1,197 @@
+import type { EntityPath } from '@data-client/normalizr';
+
+import { GC } from '../actionTypes.js';
+import Controller from '../controller/Controller.js';
+
+export class GCPolicy implements GCInterface {
+  protected endpointCount = new Map<string, number>();
+  protected entityCount = new Map<string, Map<string, number>>();
+  protected endpointsQ = new Set<string>();
+  protected entitiesQ: EntityPath[] = [];
+
+  declare protected intervalId: ReturnType<typeof setInterval>;
+  declare protected controller: Controller;
+  declare protected options: Required<Omit<GCOptions, 'expiresAt'>>;
+
+  constructor({
+    // every 5 min
+    intervalMS = 60 * 1000 * 5,
+    expiryMultiplier = 2,
+    expiresAt,
+  }: GCOptions = {}) {
+    if (expiresAt) {
+      this.expiresAt = expiresAt.bind(this);
+    }
+    this.options = {
+      intervalMS,
+      expiryMultiplier,
+    };
+  }
+
+  init(controller: Controller) {
+    this.controller = controller;
+
+    this.intervalId = setInterval(() => {
+      this.idleCallback(() => this.runSweep(), { timeout: 1000 });
+    }, this.options.intervalMS);
+  }
+
+  cleanup() {
+    clearInterval(this.intervalId);
+  }
+
+  createCountRef({ key, paths = [] }: { key?: string; paths?: EntityPath[] }) {
+    // increment
+    return () => {
+      if (key)
+        this.endpointCount.set(key, (this.endpointCount.get(key) ?? 0) + 1);
+      paths.forEach(path => {
+        if (!this.entityCount.has(path.key)) {
+          this.entityCount.set(path.key, new Map<string, number>());
+        }
+        const instanceCount = this.entityCount.get(path.key)!;
+        instanceCount.set(path.pk, (instanceCount.get(path.pk) ?? 0) + 1);
+      });
+
+      // decrement
+      return () => {
+        if (key) {
+          const currentCount = this.endpointCount.get(key)!;
+          if (currentCount !== undefined) {
+            if (currentCount <= 1) {
+              this.endpointCount.delete(key);
+              // queue for cleanup
+              this.endpointsQ.add(key);
+            } else {
+              this.endpointCount.set(key, currentCount - 1);
+            }
+          }
+        }
+        paths.forEach(path => {
+          if (!this.entityCount.has(path.key)) {
+            return;
+          }
+          const instanceCount = this.entityCount.get(path.key)!;
+          const entityCount = instanceCount.get(path.pk)!;
+          if (entityCount !== undefined) {
+            if (entityCount <= 1) {
+              instanceCount.delete(path.pk);
+              // queue for cleanup
+              this.entitiesQ.push(path);
+            } else {
+              instanceCount.set(path.pk, entityCount - 1);
+            }
+          }
+        });
+      };
+    };
+  }
+
+  protected expiresAt({
+    fetchedAt,
+    expiresAt,
+  }: {
+    expiresAt: number;
+    date: number;
+    fetchedAt: number;
+  }): number {
+    return (
+      Math.max(
+        (expiresAt - fetchedAt) * this.options.expiryMultiplier,
+        120000,
+      ) + fetchedAt
+    );
+  }
+
+  protected runSweep() {
+    const state = this.controller.getState();
+    const entities: EntityPath[] = [];
+    const endpoints: string[] = [];
+    const now = Date.now();
+
+    const nextEndpointsQ = new Set<string>();
+    for (const key of this.endpointsQ) {
+      if (
+        !this.endpointCount.has(key) &&
+        this.expiresAt(
+          state.meta[key] ?? {
+            fetchedAt: 0,
+            date: 0,
+            expiresAt: 0,
+          },
+        ) < now
+      ) {
+        endpoints.push(key);
+      } else {
+        nextEndpointsQ.add(key);
+      }
+    }
+    this.endpointsQ = nextEndpointsQ;
+
+    const nextEntitiesQ: EntityPath[] = [];
+    for (const path of this.entitiesQ) {
+      if (
+        !this.entityCount.get(path.key)?.has(path.pk) &&
+        this.expiresAt(
+          state.entityMeta[path.key]?.[path.pk] ?? {
+            fetchedAt: 0,
+            date: 0,
+            expiresAt: 0,
+          },
+        ) < now
+      ) {
+        entities.push(path);
+      } else {
+        nextEntitiesQ.push(path);
+      }
+    }
+    this.entitiesQ = nextEntitiesQ;
+
+    if (entities.length || endpoints.length) {
+      this.controller.dispatch({ type: GC, entities, endpoints });
+    }
+  }
+
+  /** Calls the callback when client is not 'busy' with high priority interaction tasks
+   *
+   * Override for platform-specific implementations
+   */
+  protected idleCallback(
+    callback: (...args: any[]) => void,
+    options?: IdleRequestOptions,
+  ) {
+    if (typeof requestIdleCallback === 'function') {
+      requestIdleCallback(callback, options);
+    } else {
+      callback();
+    }
+  }
+}
+
+export class ImmortalGCPolicy implements GCInterface {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  init() {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  cleanup() {}
+  createCountRef() {
+    return () => () => undefined;
+  }
+}
+
+export interface GCOptions {
+  intervalMS?: number;
+  expiryMultiplier?: number;
+  expiresAt?: (meta: {
+    expiresAt: number;
+    date: number;
+    fetchedAt: number;
+  }) => number;
+}
+export interface CreateCountRef {
+  ({ key, paths }: { key?: string; paths?: EntityPath[] }): () => () => void;
+}
+export interface GCInterface {
+  createCountRef: CreateCountRef;
+  init(controller: Controller): void;
+  cleanup(): void;
+}

package/src/state/__tests__/GCPolicy.test.ts

@@ -0,0 +1,258 @@
+import type { EntityPath } from '@data-client/normalizr';
+import { jest } from '@jest/globals';
+import { has } from 'benchmark';
+
+import { GC } from '../../actionTypes';
+import Controller from '../../controller/Controller';
+import { GCPolicy } from '../GCPolicy';
+
+describe('GCPolicy', () => {
+  let gcPolicy: GCPolicy;
+  let controller: Controller;
+
+  beforeEach(() => {
+    controller = {
+      getState: jest.fn(),
+      dispatch: jest.fn(),
+    } as unknown as Controller;
+    gcPolicy = new GCPolicy();
+    gcPolicy.init(controller);
+  });
+
+  afterEach(() => {
+    gcPolicy.cleanup();
+  });
+
+  it('should increment and decrement endpoint and entity counts', () => {
+    const key = 'testEndpoint';
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
+    const countRef = gcPolicy.createCountRef({ key, paths });
+
+    const decrement = countRef();
+    expect(gcPolicy['endpointCount'].get(key)).toBe(1);
+    expect(gcPolicy['entityCount'].get('testEntity')?.get('1')).toBe(1);
+
+    decrement();
+    expect(gcPolicy['endpointCount'].get(key)).toBeUndefined();
+    expect(gcPolicy['entityCount'].get('testEntity')?.get('1')).toBeUndefined();
+  });
+
+  it('should dispatch GC action once no ref counts and is expired', () => {
+    const key = 'testEndpoint';
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
+    const state = {
+      meta: {
+        testEndpoint: {
+          date: 0,
+          fetchedAt: 0,
+          expiresAt: 0,
+        },
+      },
+      entityMeta: {
+        testEntity: {
+          '1': {
+            date: 0,
+            fetchedAt: 0,
+            expiresAt: 0,
+          },
+        },
+      },
+    };
+    (controller.getState as jest.Mock).mockReturnValue(state);
+
+    const countRef = gcPolicy.createCountRef({ key, paths });
+
+    const decrement = countRef();
+    countRef(); // Increment again
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).not.toHaveBeenCalled();
+    decrement();
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).not.toHaveBeenCalled();
+    decrement(); // Decrement twice
+
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).toHaveBeenCalledWith({
+      type: GC,
+      entities: [{ key: 'testEntity', pk: '1' }],
+      endpoints: ['testEndpoint'],
+    });
+  });
+
+  it('should dispatch GC action once no ref counts and is expired with extra decrements', () => {
+    const key = 'testEndpoint';
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
+    const state = {
+      meta: {
+        testEndpoint: {
+          date: 0,
+          fetchedAt: 0,
+          expiresAt: 0,
+        },
+      },
+      entityMeta: {
+        testEntity: {
+          '1': {
+            date: 0,
+            fetchedAt: 0,
+            expiresAt: 0,
+          },
+        },
+      },
+    };
+    (controller.getState as jest.Mock).mockReturnValue(state);
+
+    const countRef = gcPolicy.createCountRef({ key, paths });
+
+    const decrement = countRef();
+    countRef(); // Increment again
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).not.toHaveBeenCalled();
+    decrement();
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).not.toHaveBeenCalled();
+    decrement(); // Decrement twice
+    decrement(); // Decrement extra time
+
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).toHaveBeenCalledWith({
+      type: GC,
+      entities: [{ key: 'testEntity', pk: '1' }],
+      endpoints: ['testEndpoint'],
+    });
+  });
+
+  it('should dispatch GC action once no ref counts and no expiry state', () => {
+    const key = 'testEndpoint';
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
+    const state = {
+      meta: {},
+      entityMeta: {},
+    };
+    (controller.getState as jest.Mock).mockReturnValue(state);
+
+    const countRef = gcPolicy.createCountRef({ key, paths });
+
+    const decrement = countRef();
+    countRef(); // Increment again
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).not.toHaveBeenCalled();
+    decrement();
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).not.toHaveBeenCalled();
+    decrement(); // Decrement twice
+
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).toHaveBeenCalledWith({
+      type: GC,
+      entities: [{ key: 'testEntity', pk: '1' }],
+      endpoints: ['testEndpoint'],
+    });
+  });
+
+  it('should not dispatch GC action if expiresAt has not passed, but dispatch later when it has', () => {
+    jest.useFakeTimers();
+    const key = 'testEndpoint';
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
+    const futureTime = Date.now() + 1000;
+    const state = {
+      meta: {
+        testEndpoint: {
+          date: futureTime - 100,
+          fetchAt: futureTime - 100,
+          expiresAt: futureTime,
+        },
+      },
+      entityMeta: {
+        testEntity: {
+          '1': {
+            date: futureTime - 100,
+            fetchAt: futureTime - 100,
+            expiresAt: futureTime,
+          },
+        },
+      },
+    };
+    (controller.getState as jest.Mock).mockReturnValue(state);
+
+    const countRef = gcPolicy.createCountRef({ key, paths });
+
+    const decrement = countRef();
+    countRef(); // Increment again
+    decrement();
+    decrement(); // Decrement twice
+
+    gcPolicy['runSweep']();
+
+    expect(controller.dispatch).not.toHaveBeenCalled();
+
+    // Fast forward time to past the futureTime
+    jest.advanceTimersByTime(2000);
+    (controller.getState as jest.Mock).mockReturnValue({
+      meta: {
+        testEndpoint: {
+          date: 0,
+          fetchedAt: 0,
+          expiresAt: 0,
+        },
+      },
+      entityMeta: {
+        testEntity: {
+          '1': {
+            date: 0,
+            fetchedAt: 0,
+            expiresAt: 0,
+          },
+        },
+      },
+    });
+
+    gcPolicy['runSweep']();
+
+    expect(controller.dispatch).toHaveBeenCalledWith({
+      type: GC,
+      entities: [{ key: 'testEntity', pk: '1' }],
+      endpoints: ['testEndpoint'],
+    });
+
+    jest.useRealTimers();
+  });
+
+  it('should support custom hasExpired', () => {
+    jest.useFakeTimers();
+    gcPolicy = new GCPolicy({ expiresAt: () => 0 });
+    gcPolicy.init(controller);
+    const key = 'testEndpoint';
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
+    const futureTime = Date.now() + 1000;
+    const state = {
+      meta: {
+        testEndpoint: {
+          date: futureTime - 100,
+          fetchAt: futureTime - 100,
+          expiresAt: futureTime,
+        },
+      },
+      entityMeta: {
+        testEntity: {
+          '1': {
+            date: futureTime - 100,
+            fetchAt: futureTime - 100,
+            expiresAt: futureTime,
+          },
+        },
+      },
+    };
+    (controller.getState as jest.Mock).mockReturnValue(state);
+
+    const countRef = gcPolicy.createCountRef({ key, paths });
+
+    const decrement = countRef();
+    countRef(); // Increment again
+    decrement();
+    decrement(); // Decrement twice
+
+    gcPolicy['runSweep']();
+    expect(controller.dispatch).toHaveBeenCalled();
+  });
+});

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

@@ -13,6 +13,7 @@ exports[`reducer should set error in meta for "set" 1`] = `
       "error": [Error: hi],
       "errorPolicy": undefined,
       "expiresAt": 5000500000,
+      "fetchedAt": 5000000000,
     },
   },
   "optimistic": [],
@@ -48,6 +49,7 @@ exports[`reducer singles should update state correctly 1`] = `
     "http://test.com/article/20": {
       "date": 5000000000,
       "expiresAt": 5000500000,
+      "fetchedAt": 5000000000,
       "prevExpiresAt": undefined,
     },
   },

package/src/state/__tests__/reducer.ts

@@ -712,8 +712,8 @@ describe('reducer', () => {
       const action: GCAction = {
         type: GC,
         entities: [
-          [Article.key, '10'],
-          [Article.key, '250'],
+          { key: Article.key, pk: '10' },
+          { key: Article.key, pk: '250' },
         ],
         endpoints: ['abc'],
       };
@@ -731,8 +731,8 @@ describe('reducer', () => {
       const action: GCAction = {
         type: GC,
         entities: [
-          [Article.key, '100000000'],
-          ['sillythings', '10'],
+          { key: Article.key, pk: '100000000' },
+          { key: 'sillythings', pk: '10' },
         ],
         endpoints: [],
       };

package/src/state/reducer/createReducer.ts

@@ -26,7 +26,7 @@ export default function createReducer(controller: Controller): ReducerType {
     switch (action.type) {
       case GC:
         // inline deletes are fine as these should have 0 refcounts
-        action.entities.forEach(([key, pk]) => {
+        action.entities.forEach(({ key, pk }) => {
           delete (state as any).entities[key]?.[pk];
           delete (state as any).entityMeta[key]?.[pk];
         });

package/src/state/reducer/setResponseReducer.ts

@@ -75,6 +75,7 @@ export function setResponseReducer(
         ...state.meta,
         [action.key]: {
           date: action.meta.date,
+          fetchedAt: action.meta.fetchedAt,
           expiresAt: action.meta.expiresAt,
           prevExpiresAt: state.meta[action.key]?.expiresAt,
         },
@@ -126,8 +127,9 @@ function reduceError(
       ...state.meta,
       [action.key]: {
         date: action.meta.date,
-        error,
+        fetchedAt: action.meta.fetchedAt,
         expiresAt: action.meta.expiresAt,
+        error,
         errorPolicy: action.endpoint.errorPolicy?.(error),
       },
     },

package/src/types.ts

@@ -33,6 +33,7 @@ export interface State<T> {
   readonly meta: {
     readonly [key: string]: {
       readonly date: number;
+      readonly fetchedAt: number;
       readonly expiresAt: number;
       readonly prevExpiresAt?: number;
       readonly error?: ErrorTypes;

package/ts3.4/actions.d.ts

@@ -1,4 +1,4 @@
-import { Denormalize, EndpointInterface, Queryable, ResolveType, UnknownError } from '@data-client/normalizr';
+import { Denormalize, EndpointInterface, EntityPath, Queryable, ResolveType, UnknownError } from '@data-client/normalizr';
 import { SET, RESET, FETCH, SUBSCRIBE, UNSUBSCRIBE, INVALIDATE, GC, OPTIMISTIC, INVALIDATEALL, EXPIREALL, SET_RESPONSE } from './actionTypes.js';
 import { EndpointUpdateFunction } from './controller/types.js';
 type EndpointAndUpdate<E extends EndpointInterface> = EndpointInterface & {
@@ -95,10 +95,7 @@ export interface ResetAction {
 }
 export interface GCAction {
     type: typeof GC;
-    entities: [
-        string,
-        string
-    ][];
+    entities: EntityPath[];
     endpoints: string[];
 }
 /** @see https://dataclient.io/docs/api/Actions */