@data-client/core 0.10.0 → 0.11.0

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

package/src/state/__tests__/reducer.ts

@@ -207,7 +207,7 @@ describe('reducer', () => {
     });
   });
 
-  it('mutate should never change results', () => {
+  it('mutate should never change endpoints', () => {
     const id = 20;
     const payload = { id, title: 'hi', content: 'this is the content' };
     const action: SetAction = {
@@ -224,10 +224,10 @@ describe('reducer', () => {
     };
     const iniState = {
       ...initialState,
-      results: { abc: '5', [ArticleResource.get.key(payload)]: `${id}` },
+      endpoints: { abc: '5', [ArticleResource.get.key(payload)]: `${id}` },
     };
     const newState = reducer(iniState, action);
-    expect(newState.results).toStrictEqual(iniState.results);
+    expect(newState.endpoints).toStrictEqual(iniState.endpoints);
   });
   it('purge should delete entities', () => {
     const id = 20;
@@ -256,10 +256,10 @@ describe('reducer', () => {
         },
         '5': undefined,
       },
-      results: { abc: '20' },
+      endpoints: { abc: '20' },
     };
     const newState = reducer(iniState, action);
-    expect(newState.results.abc).toBe(iniState.results.abc);
+    expect(newState.endpoints.abc).toBe(iniState.endpoints.abc);
     const expectedEntities = { ...iniState.entities[Article.key] };
     expectedEntities['20'] = INVALID;
     expect(newState.entities[Article.key]).toEqual(expectedEntities);
@@ -277,8 +277,8 @@ describe('reducer', () => {
             '10': PaginatedArticle.fromJS({ id: 10 }),
           },
         },
-        results: {
-          [PaginatedArticleResource.getList.key({})]: { results: ['10'] },
+        endpoints: {
+          [PaginatedArticleResource.getList.key({})]: { endpoints: ['10'] },
         },
       };
 
@@ -301,7 +301,7 @@ describe('reducer', () => {
         );
         const newState = reducer(iniState, action);
         expect(
-          newState.results[PaginatedArticleResource.getList.key({})],
+          newState.endpoints[PaginatedArticleResource.getList.key({})],
         ).toStrictEqual({
           results: ['10', '11', '12'],
         });
@@ -328,7 +328,7 @@ describe('reducer', () => {
           ),
         );
         expect(
-          newState.results[PaginatedArticleResource.getList.key({})],
+          newState.endpoints[PaginatedArticleResource.getList.key({})],
         ).toStrictEqual({
           results: ['11', '12', '10'],
         });
@@ -342,7 +342,7 @@ describe('reducer', () => {
               '10': PaginatedArticle.fromJS({ id: 10 }),
             },
           },
-          results: {
+          endpoints: {
             [PaginatedArticleResource.getList.key({ admin: true })]: {
               results: ['10'],
             },
@@ -369,7 +369,7 @@ describe('reducer', () => {
           ),
         );
         expect(
-          newState.results[
+          newState.endpoints[
             PaginatedArticleResource.getList.key({ admin: true })
           ],
         ).toStrictEqual({
@@ -400,7 +400,7 @@ describe('reducer', () => {
         },
         '5': undefined,
       },
-      results: { abc: '20' },
+      endpoints: { abc: '20' },
       meta: {
         '20': {
           expiresAt: 500,
@@ -411,7 +411,7 @@ describe('reducer', () => {
       },
     };
     const newState = reducer(iniState, action);
-    expect(newState.results).toEqual(iniState.results);
+    expect(newState.endpoints).toEqual(iniState.endpoints);
     expect(newState.entities).toBe(iniState.entities);
     const expectedMeta = { ...iniState.meta };
     expectedMeta['20'] = { expiresAt: 0, invalidated: true };
@@ -481,7 +481,7 @@ describe('reducer', () => {
           [id]: Article.fromJS({}),
         },
       },
-      results: {
+      endpoints: {
         [ArticleResource.get.url({ id })]: id,
       },
     };
@@ -509,7 +509,7 @@ describe('reducer', () => {
       };
       const iniState = {
         ...initialState,
-        results: { abc: '5' },
+        endpoints: { abc: '5' },
       };
       const newState = reducer(iniState, action);
       expect(newState).toBe(iniState);
@@ -524,7 +524,7 @@ describe('reducer', () => {
     };
     const iniState = {
       ...initialState,
-      results: { abc: '5' },
+      endpoints: { abc: '5' },
     };
     const newState = reducer(iniState, action);
     expect(newState).toBe(iniState);
@@ -556,10 +556,10 @@ describe('reducer', () => {
           },
           '5': undefined,
         },
-        results: { abc: '20' },
+        endpoints: { abc: '20' },
       };
       const newState = reducer(iniState, action);
-      expect(newState.results).toEqual({});
+      expect(newState.endpoints).toEqual({});
       expect(newState.meta).toEqual({});
       expect(newState.entities).toEqual({});
     });
@@ -591,7 +591,7 @@ describe('reducer', () => {
             '250': { date: 0, expiresAt: 10000, fetchedAt: 0 },
           },
         },
-        results: { abc: '20' },
+        endpoints: { abc: '20' },
       };
     });
 
@@ -599,13 +599,13 @@ describe('reducer', () => {
       const action: GCAction = {
         type: GC_TYPE,
         entities: [],
-        results: [],
+        endpoints: [],
       };
 
       const newState = reducer(iniState, action);
       expect(newState).toBe(iniState);
       expect(Object.keys(newState.entities[Article.key] ?? {}).length).toBe(4);
-      expect(Object.keys(newState.results).length).toBe(1);
+      expect(Object.keys(newState.endpoints).length).toBe(1);
     });
 
     it('empty deleting entities should work', () => {
@@ -615,7 +615,7 @@ describe('reducer', () => {
           [Article.key, '10'],
           [Article.key, '250'],
         ],
-        results: ['abc'],
+        endpoints: ['abc'],
       };
 
       const newState = reducer(iniState, action);
@@ -624,7 +624,7 @@ describe('reducer', () => {
       expect(Object.keys(newState.entityMeta[Article.key] ?? {}).length).toBe(
         2,
       );
-      expect(Object.keys(newState.results).length).toBe(0);
+      expect(Object.keys(newState.endpoints).length).toBe(0);
     });
 
     it('empty deleting nonexistant things should passthrough', () => {
@@ -634,13 +634,13 @@ describe('reducer', () => {
           [Article.key, '100000000'],
           ['sillythings', '10'],
         ],
-        results: [],
+        endpoints: [],
       };
 
       const newState = reducer(iniState, action);
       expect(newState).toBe(iniState);
       expect(Object.keys(newState.entities[Article.key] ?? {}).length).toBe(4);
-      expect(Object.keys(newState.results).length).toBe(1);
+      expect(Object.keys(newState.endpoints).length).toBe(1);
     });
   });
 });