@data-client/core 0.10.0 → 0.11.4

package/src/controller/__tests__/Controller.ts

@@ -1,9 +1,7 @@
-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 Controller from '../Controller';
 
@@ -45,7 +43,7 @@ describe('Controller', () => {
       const state = {
         ...initialState,
         entities,
-        results: {
+        endpoints: {
           [fetchKey]: result,
         },
         entityMeta: createEntityMeta(entities),
@@ -82,7 +80,7 @@ describe('Controller', () => {
       const state = {
         ...initialState,
         entities,
-        results: {
+        endpoints: {
           [fetchKey]: result,
         },
         entityMeta: createEntityMeta(entities),

package/src/controller/__tests__/__snapshots__/get.ts.snap

@@ -0,0 +1,120 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Controller.get() Query+All based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.get() Query+All based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() Query+All based on args 3`] = `
+[
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+  Tacos {
+    "id": "3",
+    "name": "thing3",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() Union based on args 1`] = `
+User {
+  "id": "1",
+  "type": "users",
+  "username": "bob",
+}
+`;
+
+exports[`Controller.get() Union based on args 2`] = `
+Group {
+  "groupname": "fast",
+  "id": "2",
+  "memberCount": 5,
+  "type": "groups",
+}
+`;
+
+exports[`Controller.get() query All should get all entities 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() query All should include new entities when added 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+  Tacos {
+    "id": "3",
+    "type": "extra",
+  },
+]
+`;
+
+exports[`Controller.get() query Collection based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.get() query Collection based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.get() query Entity based on index 1`] = `
+User {
+  "id": "1",
+  "username": "bob",
+}
+`;
+
+exports[`Controller.get() query Entity based on pk 1`] = `
+Tacos {
+  "id": "1",
+  "type": "foo",
+}
+`;

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/index.ts

@@ -13,13 +13,15 @@ export type {
   EndpointInterface,
   EntityInterface,
   ResolveType,
-  DenormalizeCache,
   DenormalizeNullable,
   Denormalize,
   Normalize,
   NormalizeNullable,
   FetchFunction,
   EndpointExtraOptions,
+  Queryable,
+  SchemaArgs,
+  NI,
 } 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/__tests__/logoutManager.ts

@@ -65,7 +65,6 @@ describe('LogoutManager', () => {
       expect(dispatch.mock.calls.length).toBe(0);
     });
     it('should dispatch reset on 401', async () => {
-      jest.setSystemTime(0);
       const error: any = new Error('network failed');
       error.status = 401;
       const action = createSet(CoolerArticleResource.get, {
@@ -87,7 +86,6 @@ describe('LogoutManager', () => {
         },
         handleLogout,
       }).getMiddleware();
-      jest.setSystemTime(0);
       const error: any = new Error('network failed');
       error.status = 403;
       const action = createSet(CoolerArticleResource.get, {

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",
-  },
 }
 `;