@data-client/core 0.9.7 → 0.11.0

package/src/controller/__tests__/get.ts

@@ -0,0 +1,285 @@
+import { Entity, schema } from '@data-client/endpoint';
+
+import { initialState } from '../../state/reducer/createReducer';
+import Controller from '../Controller';
+
+describe('Controller.get()', () => {
+  class Tacos extends Entity {
+    type = '';
+    id = '';
+    pk() {
+      return this.id;
+    }
+  }
+  const TacoList = new schema.Collection([Tacos]);
+  const entities = {
+    Tacos: {
+      1: { id: '1', type: 'foo' },
+      2: { id: '2', type: 'bar' },
+    },
+    [TacoList.key]: {
+      [TacoList.pk(undefined, undefined, '', [{ type: 'foo' }])]: ['1'],
+      [TacoList.pk(undefined, undefined, '', [{ type: 'bar' }])]: ['2'],
+      [TacoList.pk(undefined, undefined, '', [])]: ['1', '2'],
+    },
+  };
+
+  it('query Entity based on pk', () => {
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const taco = controller.get(Tacos, { id: '1' }, state);
+    expect(taco).toBeDefined();
+    expect(taco).toBeInstanceOf(Tacos);
+    expect(taco).toMatchSnapshot();
+    const taco2 = controller.get(Tacos, { id: '2' }, state);
+    expect(taco2).toBeDefined();
+    expect(taco2).toBeInstanceOf(Tacos);
+    expect(taco2).not.toEqual(taco);
+    // should maintain referential equality
+    expect(taco).toBe(controller.get(Tacos, { id: '1' }, state));
+
+    // @ts-expect-error
+    () => controller.get(Tacos, { id: { bob: 5 } }, state);
+    // @ts-expect-error
+    expect(controller.get(Tacos, 5, state)).toBeUndefined();
+    // @ts-expect-error
+    () => controller.get(Tacos, { doesnotexist: 5 }, state);
+  });
+
+  it('query Entity based on index', () => {
+    class User extends Entity {
+      id = '';
+      username = '';
+
+      pk() {
+        return this.id;
+      }
+
+      static indexes = ['username'] as const;
+    }
+
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities: {
+        User: {
+          '1': { id: '1', username: 'bob' },
+        },
+      },
+      indexes: {
+        User: {
+          username: {
+            bob: '1',
+          },
+        },
+      },
+    };
+
+    const bob = controller.get(User, { username: 'bob' }, state);
+    expect(bob).toBeDefined();
+    expect(bob).toBeInstanceOf(User);
+    expect(bob).toMatchSnapshot();
+    // should be same as id lookup
+    expect(bob).toBe(controller.get(User, { id: '1' }, state));
+  });
+
+  it('query Collection based on args', () => {
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const tacos = controller.get(TacoList, { type: 'foo' }, state);
+    expect(tacos).toBeDefined();
+    expect(tacos?.[0]).toBeInstanceOf(Tacos);
+    expect(tacos).toMatchSnapshot();
+    const tacosBars = controller.get(TacoList, { type: 'bar' }, state);
+    expect(tacosBars).toBeDefined();
+    expect(tacosBars?.[0]).toBeInstanceOf(Tacos);
+    expect(tacosBars).not.toEqual(tacos);
+    // should maintain referential equality
+    expect(tacos).toBe(controller.get(TacoList, { type: 'foo' }, state));
+
+    const allTacos = controller.get(TacoList, state);
+    expect(allTacos).toBeDefined();
+    expect(allTacos).toHaveLength(2);
+    expect(allTacos).toMatchSnapshot();
+
+    // @ts-expect-error
+    () => controller.get(TacoList, 5, state);
+  });
+
+  describe('query All', () => {
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const AllTacos = new schema.All(Tacos);
+
+    it('should get all entities', () => {
+      const allTacos = controller.get(AllTacos, state);
+      expect(allTacos).toBeDefined();
+      expect(allTacos).toHaveLength(2);
+      expect(allTacos).toMatchSnapshot();
+
+      // TODO: @ts-expect-error (we have a hack to make this not break other things now)
+      () => controller.get(AllTacos, 5, state);
+    });
+
+    it('should maintain referential equality', () => {
+      const allTacos = controller.get(AllTacos, state);
+      expect(allTacos).toStrictEqual(controller.get(TacoList, state));
+    });
+
+    it('should include new entities when added', () => {
+      controller.get(AllTacos, state);
+      const tacosWithExtra = controller.get(AllTacos, {
+        ...state,
+        entities: {
+          ...entities,
+          Tacos: {
+            ...entities.Tacos,
+            3: { id: '3', type: 'extra' },
+          },
+        },
+      });
+      expect(tacosWithExtra).toBeDefined();
+      expect(tacosWithExtra).toHaveLength(3);
+      expect(tacosWithExtra).toMatchSnapshot();
+    });
+  });
+
+  it('Query+All based on args', () => {
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const queryTacos = new schema.Query(
+      new schema.All(Tacos),
+      (tacos, { type }: { type?: string } = {}) => {
+        if (!type) return tacos;
+        return tacos.filter(taco => taco.type === type);
+      },
+    );
+
+    const tacos = controller.get(queryTacos, { type: 'foo' }, state);
+    expect(tacos).toBeDefined();
+    expect(tacos?.[0]).toBeInstanceOf(Tacos);
+    expect(tacos).toMatchSnapshot();
+    const tacosBars = controller.get(queryTacos, { type: 'bar' }, state);
+    expect(tacosBars).toBeDefined();
+    expect(tacosBars?.[0]).toBeInstanceOf(Tacos);
+    expect(tacosBars).not.toEqual(tacos);
+    // should maintain referential equality
+    expect(tacos).toBe(controller.get(queryTacos, { type: 'foo' }, state));
+
+    const allTacos = controller.get(queryTacos, state);
+    expect(allTacos).toBeDefined();
+    expect(allTacos).toHaveLength(2);
+    expect(allTacos).toMatchSnapshot();
+
+    // @ts-expect-error
+    () => controller.get(queryTacos, 5, state);
+
+    const tacosWithExtra = controller.get(
+      queryTacos,
+      { type: 'bar' },
+      {
+        ...state,
+        entities: {
+          ...entities,
+          Tacos: {
+            ...entities.Tacos,
+            3: { id: '3', type: 'bar', name: 'thing3' },
+          },
+        },
+      },
+    );
+    expect(tacosWithExtra).toBeDefined();
+    expect(tacosWithExtra).toHaveLength(2);
+    expect(tacosWithExtra).toMatchSnapshot();
+  });
+
+  it('Query+Collection based on args', () => {
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const tacoCount = new schema.Query(TacoList, tacos => {
+      return tacos?.length ?? 0;
+    });
+
+    expect(controller.get(tacoCount, { type: 'foo' }, state)).toBe(1);
+    expect(controller.get(tacoCount, { type: 'bar' }, state)).toBe(1);
+    expect(controller.get(tacoCount, state)).toBe(2);
+  });
+
+  it('Union based on args', () => {
+    class IDEntity extends Entity {
+      id: string = '';
+      pk() {
+        return this.id;
+      }
+    }
+    class User extends IDEntity {
+      type = 'user';
+      username: string = '';
+    }
+    class Group extends IDEntity {
+      type = 'group';
+      groupname: string = '';
+      memberCount = 0;
+    }
+    const queryPerson = new schema.Union(
+      {
+        users: User,
+        groups: Group,
+      },
+      'type',
+    );
+    const controller = new Controller();
+    const state = {
+      ...initialState,
+      entities: {
+        User: {
+          '1': { id: '1', type: 'users', username: 'bob' },
+        },
+        Group: {
+          '2': { id: '2', type: 'groups', groupname: 'fast', memberCount: 5 },
+        },
+      },
+    };
+    const user = controller.get(queryPerson, { id: '1', type: 'users' }, state);
+    expect(user).toBeDefined();
+    expect(user).toBeInstanceOf(User);
+    expect(user).toMatchSnapshot();
+    const group = controller.get(
+      queryPerson,
+      { id: '2', type: 'groups' },
+      state,
+    );
+    expect(group).toBeDefined();
+    expect(group).toBeInstanceOf(Group);
+    expect(group).toMatchSnapshot();
+
+    // should maintain referential equality
+    expect(user).toBe(
+      controller.get(queryPerson, { id: '1', type: 'users' }, state),
+    );
+
+    // @ts-expect-error
+    () => controller.get(queryPerson, { id: { bob: 5 } }, state);
+    // @ts-expect-error
+    expect(controller.get(queryPerson, 5, state)).toBeUndefined();
+    // @ts-expect-error
+    () => controller.get(queryPerson, { doesnotexist: 5 }, state);
+    // @ts-expect-error
+    () => controller.get(queryPerson, { id: '1', doesnotexist: 5 }, state);
+  });
+});

package/src/controller/__tests__/getResponse.ts

@@ -39,7 +39,7 @@ describe('Controller.getResponse()', () => {
     const state = {
       ...initialState,
       entities,
-      results: {
+      endpoints: {
         [ep.key()]: {
           data: ['1', '2'],
         },
@@ -84,7 +84,7 @@ describe('Controller.getResponse()', () => {
     const state = {
       ...initialState,
       entities,
-      results: {
+      endpoints: {
         [ep.key()]: {
           data: ['1', '2'],
         },

package/src/controller/createSet.ts

@@ -51,8 +51,9 @@ export default function createSet<
     error?: boolean;
   },
 ): SetAction<E> {
-  const expiryLength: number = error
-    ? endpoint.errorExpiryLength ?? 1000
+  const expiryLength: number =
+    error ?
+      endpoint.errorExpiryLength ?? 1000
     : endpoint.dataExpiryLength ?? 60000;
   /* istanbul ignore next */
   if (process.env.NODE_ENV === 'development' && expiryLength < 0) {

package/src/controller/ensurePojo.ts

@@ -1,11 +1,10 @@
 export const ensurePojo =
   // FormData doesn't exist in node
   /* istanbul ignore else we don't run coverage when we test node*/
-  typeof FormData !== 'undefined'
-    ? (body: any) =>
-        body instanceof FormData
-          ? Object.fromEntries((body as any).entries())
-          : body
-    : /* istanbul ignore next */
-      (body: any) => body;
+  typeof FormData !== 'undefined' ?
+    (body: any) =>
+      body instanceof FormData ?
+        Object.fromEntries((body as any).entries())
+      : body
+  : /* istanbul ignore next */ (body: any) => body;
 export default ensurePojo;

package/src/controller/types.ts

@@ -4,10 +4,8 @@ import type {
   ResolveType,
 } from '@data-client/normalizr';
 
-export type ResultEntry<E extends EndpointInterface> = E['schema'] extends
-  | undefined
-  | null
-  ? ResolveType<E>
+export type ResultEntry<E extends EndpointInterface> =
+  E['schema'] extends undefined | null ? ResolveType<E>
   : Normalize<E['schema']>;
 
 export type EndpointUpdateFunction<

package/src/index.ts

@@ -13,13 +13,14 @@ export type {
   EndpointInterface,
   EntityInterface,
   ResolveType,
-  DenormalizeCache,
   DenormalizeNullable,
   Denormalize,
   Normalize,
   NormalizeNullable,
   FetchFunction,
   EndpointExtraOptions,
+  Queryable,
+  SchemaArgs,
 } from '@data-client/normalizr';
 export { ExpiryStatus } from '@data-client/normalizr';
 export {

package/src/internal.ts

@@ -1,3 +1,3 @@
-export { inferResults, INVALID } from '@data-client/normalizr';
+export { MemoCache, 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

@@ -47,8 +47,9 @@ if (process.env.NODE_ENV !== 'production') {
     serialize: {
       options: undefined,
       /* istanbul ignore next */
-      replacer: HASINTL
-        ? (key: string | number | symbol, value: unknown) => {
+      replacer:
+        HASINTL ?
+          (key: string | number | symbol, value: unknown) => {
             if (
               typeof value === 'number' &&
               typeof key === 'string' &&
@@ -81,6 +82,7 @@ export default class DevToolsManager implements Manager {
   protected started = false;
   protected actions: [ActionTypes, State<unknown>][] = [];
   protected declare controller: Controller;
+  maxBufferLength = 100;
 
   constructor(
     config?: DevToolsConfig,
@@ -150,6 +152,10 @@ export default class DevToolsManager implements Manager {
     if (this.started) {
       this.devTools.send(action, state, undefined, 'RDC');
     } else {
+      // avoid this getting too big in case this is long running
+      // we cut in half so we aren't constantly reallocating
+      if (this.actions.length > this.maxBufferLength)
+        this.actions = this.actions.slice(this.maxBufferLength / 2);
       // queue actions
       this.actions.push([action, state]);
     }

package/src/manager/__tests__/subscriptionManager.ts

@@ -51,8 +51,9 @@ describe('SubscriptionManager', () => {
       payload: Record<string, any>,
       reject = false,
     ): SubscribeAction {
-      const fetch = reject
-        ? () => Promise.reject(new Error('Failed'))
+      const fetch =
+        reject ?
+          () => Promise.reject(new Error('Failed'))
         : () => Promise.resolve(payload);
       return {
         type: SUBSCRIBE_TYPE,

package/src/middlewareTypes.ts

@@ -25,15 +25,7 @@ export type Dispatch<R extends Reducer<any, any>> = (
 ) => 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;
+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/state/RIC.ts

@@ -1,6 +1,5 @@
 const RIC: (cb: (...args: any[]) => void, options: any) => void = (
-  typeof requestIdleCallback === 'function'
-    ? requestIdleCallback
-    : (cb: any) => setTimeout(cb, 0)
-) as any;
+  typeof requestIdleCallback === 'function' ? requestIdleCallback : (
+    (cb: any) => setTimeout(cb, 0)
+  )) as any;
 export default RIC;

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

@@ -2,6 +2,7 @@
 
 exports[`reducer should set error in meta for "set" 1`] = `
 {
+  "endpoints": {},
   "entities": {},
   "entityMeta": {},
   "indexes": {},
@@ -15,12 +16,14 @@ exports[`reducer should set error in meta for "set" 1`] = `
     },
   },
   "optimistic": [],
-  "results": {},
 }
 `;
 
 exports[`reducer singles should update state correctly 1`] = `
 {
+  "endpoints": {
+    "http://test.com/article/20": "20",
+  },
   "entities": {
     "Article": {
       "20": {
@@ -49,8 +52,5 @@ exports[`reducer singles should update state correctly 1`] = `
     },
   },
   "optimistic": [],
-  "results": {
-    "http://test.com/article/20": "20",
-  },
 }
 `;