enhance: delegate.getEntities() returns restricted EntitiesInterface (#3501)

Author: ntucker

.changeset/proud-taxes-bake.md

@@ -3,6 +3,40 @@
 '@data-client/endpoint': minor
 ---
 
-delegate.getEntity(this.key) -> delegate.getEntities(this.key)
+delegate.getEntity(key) -> delegate.getEntities(this.key)
 
-This applies to both schema.queryKey and schema.normalize method delegates.
+Return value is a restricted interface with keys() and entries() iterator methods.
+This applies to both schema.queryKey and schema.normalize method delegates.
+
+```ts
+const entities = delegate.getEntities(key);
+
+// foreach on keys
+for (const key of entities.keys()) {}
+// Object.keys() (convert to array)
+return [...entities.keys()];
+// foreach on full entry
+for (const [key, entity] of entities.entries()) {}
+```
+
+#### Before
+
+```ts
+const entities = delegate.getEntity(this.key);
+if (entities)
+  Object.keys(entities).forEach(collectionPk => {
+    if (!filterCollections(JSON.parse(collectionPk))) return;
+    delegate.mergeEntity(this, collectionPk, normalizedValue);
+  });
+```
+
+#### After
+
+```ts
+const entities = delegate.getEntities(this.key);
+if (entities)
+  for (const collectionKey of entities.keys()) {
+    if (!filterCollections(JSON.parse(collectionKey))) continue;
+    delegate.mergeEntity(this, collectionKey, normalizedValue);
+  }
+```

.changeset/thirty-islands-hope.md

@@ -0,0 +1,8 @@
+---
+'@data-client/endpoint': patch
+---
+
+Fix: schema.All() polymorphic handling of Invalidated entities
+
+In case an Entity is invalidated, schema.All will continue to properly
+filter it out of its list.

packages/endpoint/src/interface.ts

@@ -127,10 +127,12 @@ export interface CheckLoop {
   (entityKey: string, pk: string, input: object): boolean;
 }
 
-/** Get all normalized entities of one type from store */
-export interface GetEntities {
-  (key: string): { readonly [pk: string]: any } | undefined;
+/** Interface specification for entities state accessor */
+export interface EntitiesInterface {
+  keys(): IterableIterator<string>;
+  entries(): IterableIterator<[string, any]>;
 }
+
 /** Get normalized Entity from store */
 export interface GetEntity {
   (key: string, pk: string): any;
@@ -143,8 +145,11 @@ export interface GetIndex {
 
 /** Accessors to the currently processing state while building query */
 export interface IQueryDelegate {
-  getEntities: GetEntities;
+  /** Get all entities for a given schema key */
+  getEntities(key: string): EntitiesInterface | undefined;
+  /** Gets any previously normalized entity from store */
   getEntity: GetEntity;
+  /** Get PK using an Entity Index */
   getIndex: GetIndex;
   /** Return to consider results invalid */
   INVALID: symbol;
@@ -154,8 +159,8 @@ export interface IQueryDelegate {
 export interface INormalizeDelegate {
   /** Action meta-data for this normalize call */
   readonly meta: { fetchedAt: number; date: number; expiresAt: number };
-  /** Get all normalized entities of one type from store */
-  getEntities: GetEntities;
+  /** Get all entities for a given schema key */
+  getEntities(key: string): EntitiesInterface | undefined;
   /** Gets any previously normalized entity from store */
   getEntity: GetEntity;
   /** Updates an entity using merge lifecycles when it has previously been set */

packages/endpoint/src/schemas/All.ts

@@ -1,6 +1,11 @@
 import ArraySchema from './Array.js';
 import { IQueryDelegate, Visit } from '../interface.js';
-import { EntityInterface, EntityMap, SchemaFunction } from '../schema.js';
+import {
+  Entity,
+  EntityInterface,
+  EntityMap,
+  SchemaFunction,
+} from '../schema.js';
 
 /**
  * Retrieves all entities in cache
@@ -26,23 +31,25 @@ export default class AllSchema<
 
   queryKey(args: any, unvisit: any, delegate: IQueryDelegate): any {
     if (this.isSingleSchema) {
-      const entitiesEntry = delegate.getEntities(this.schema.key);
-      // we must wait until there are entries for any 'All' query to be Valid
-      if (entitiesEntry === undefined) return delegate.INVALID;
-      return Object.values(entitiesEntry).map(
-        entity => entity && this.schema.pk(entity),
-      );
+      const entities = delegate.getEntities(this.schema.key);
+      if (!entities) return delegate.INVALID;
+      return [...entities.keys()];
     }
     let found = false;
     const list = Object.values(this.schema as Record<string, any>).flatMap(
       (schema: EntityInterface) => {
-        const entitiesEntry = delegate.getEntities(schema.key);
-        if (entitiesEntry === undefined) return [];
+        const entities = delegate.getEntities(schema.key);
+        if (!entities) return [];
         found = true;
-        return Object.entries(entitiesEntry).map(([key, entity]) => ({
-          id: entity && schema.pk(entity, undefined, key, []),
-          schema: this.getSchemaAttribute(entity, undefined, key),
-        }));
+        const normEntities: any[] = [];
+        for (const [key, entity] of entities.entries()) {
+          if (!entity || typeof entity === 'symbol') continue;
+          normEntities.push({
+            id: schema.pk(entity, undefined, key, []),
+            schema: this.getSchemaAttribute(entity, undefined, key),
+          });
+        }
+        return normEntities;
       },
     );
     // we need at least one table entry of the Union for this to count as Valid.

packages/endpoint/src/schemas/Collection.ts

@@ -328,10 +328,10 @@ function normalizeCreate(
   // add to any collections that match this
   const entities = delegate.getEntities(this.key);
   if (entities)
-    Object.keys(entities).forEach(collectionPk => {
-      if (!filterCollections(JSON.parse(collectionPk))) return;
-      delegate.mergeEntity(this, collectionPk, normalizedValue);
-    });
+    for (const collectionKey of entities.keys()) {
+      if (!filterCollections(JSON.parse(collectionKey))) continue;
+      delegate.mergeEntity(this, collectionKey, normalizedValue);
+    }
   return normalizedValue as any;
 }
 

packages/endpoint/src/schemas/__tests__/All.test.ts

@@ -200,21 +200,65 @@ describe.each([
       expect(createOutput(value)).toMatchSnapshot();
     });
 
+    test('denormalizes removes undefined or INVALID entities with polymorphism', () => {
+      class Cat extends IDEntity {
+        readonly type = 'Cat';
+      }
+      class Dog extends IDEntity {
+        readonly type = 'dogs';
+      }
+      class Person extends IDEntity {
+        readonly type = 'people';
+      }
+      const listSchema = new schema.All(
+        {
+          Cat: Cat,
+          dogs: Dog,
+          people: Person,
+        },
+        input => input.type || 'dogs',
+      );
+
+      const state = createInput({
+        entities: {
+          Cat: {
+            '1': { id: '1', name: 'Milo', type: 'Cat' },
+            '2': { id: '2', name: 'Jake', type: 'Cat' },
+            '3': undefined,
+            '4': INVALID,
+          },
+          Dog: {
+            '1': { id: '1', name: 'Rex', type: 'dogs' },
+            '2': INVALID,
+          },
+          Person: {
+            '1': { id: '1', name: 'Alice', type: 'people' },
+            '2': undefined,
+          },
+        },
+        indexes: {},
+      });
+      const value = new MemoCache(MyDelegate).query(listSchema, [], state).data;
+      expect(value).not.toEqual(expect.any(Symbol));
+      if (typeof value === 'symbol' || value === undefined) return;
+      expect(createOutput(value).length).toBe(4);
+      expect(createOutput(value)).toMatchSnapshot();
+    });
+
     test('denormalize maintains referential equality until entities are added', () => {
       class Cat extends IDEntity {}
       (Cat as any).defaults;
       const catSchema = { results: new schema.All(Cat), nextPage: '' };
-      let state: State<unknown> = {
+      let state: State<unknown> = createInput({
         ...initialState,
         entities: {
           Cat: {
-            1: { id: '1', name: 'Milo' },
-            2: { id: '2', name: 'Jake' },
+            '1': { id: '1', name: 'Milo' },
+            '2': { id: '2', name: 'Jake' },
           },
         },
-        indexes: {},
-      };
-      const memo = new MemoCache();
+      }) as any;
+      const memo = new MemoCache(MyDelegate);
       const value = memo.query(catSchema, [], state).data;
 
       expect(createOutput(value).results?.length).toBe(2);
@@ -225,16 +269,27 @@ describe.each([
       );
       expect(value).toBe(value2);
 
-      state = {
-        ...state,
-        entities: {
-          ...state.entities,
-          Cat: {
-            ...state.entities.Cat,
-            3: { id: '3', name: 'Jelico' },
+      if (ImmDelegate === MyDelegate) {
+        state = {
+          ...state,
+          entities: (state.entities as any).setIn(['Cat', '3'], {
+            id: '3',
+            name: 'Jelico',
+          }),
+        } as any;
+      } else {
+        state = {
+          ...state,
+          entities: {
+            ...state.entities,
+            Cat: {
+              ...state.entities.Cat,
+              '3': { id: '3', name: 'Jelico' },
+            },
           },
-        },
-      };
+        } as any;
+      }
+
       const value3 = memo.query(catSchema, [], state).data;
       expect(createOutput(value3).results?.length).toBe(3);
       expect(createOutput(value3).results).toMatchSnapshot();

packages/endpoint/src/schemas/__tests__/Object.test.js

@@ -6,8 +6,9 @@ import {
 import { denormalize as immDenormalize } from '@data-client/normalizr/imm';
 import { Temporal } from '@js-temporal/polyfill';
 import { IDEntity } from '__tests__/new';
-import { fromJS, Map } from 'immutable';
+import { fromJS } from 'immutable';
 
+import { fromJSEntities } from './denormalize';
 import { schema } from '../../';
 import Entity from '../Entity';
 
@@ -22,10 +23,6 @@ afterAll(() => {
   dateSpy.mockRestore();
 });
 
-function fromJSEntities(entities) {
-  return Map(entities).map(v => Map(v));
-}
-
 describe(`${schema.Object.name} normalization`, () => {
   test('normalizes an object', () => {
     class User extends IDEntity {}

packages/endpoint/src/schemas/__tests__/__snapshots__/All.test.ts.snap

@@ -436,6 +436,31 @@ exports[`ArraySchema denormalization (direct) denormalizes removes undefined or
 }
 `;
 
+exports[`ArraySchema denormalization (direct) denormalizes removes undefined or INVALID entities with polymorphism 1`] = `
+[
+  Cat {
+    "id": "1",
+    "name": "Milo",
+    "type": "Cat",
+  },
+  Cat {
+    "id": "2",
+    "name": "Jake",
+    "type": "Cat",
+  },
+  Dog {
+    "id": "1",
+    "name": "Rex",
+    "type": "dogs",
+  },
+  Person {
+    "id": "1",
+    "name": "Alice",
+    "type": "people",
+  },
+]
+`;
+
 exports[`ArraySchema denormalization (direct) returns the input value if is null 1`] = `
 Taco {
   "fillings": null,
@@ -576,6 +601,31 @@ exports[`ArraySchema denormalization (immutable) denormalizes removes undefined
 }
 `;
 
+exports[`ArraySchema denormalization (immutable) denormalizes removes undefined or INVALID entities with polymorphism 1`] = `
+[
+  Cat {
+    "id": "1",
+    "name": "Milo",
+    "type": "Cat",
+  },
+  Cat {
+    "id": "2",
+    "name": "Jake",
+    "type": "Cat",
+  },
+  Dog {
+    "id": "1",
+    "name": "Rex",
+    "type": "dogs",
+  },
+  Person {
+    "id": "1",
+    "name": "Alice",
+    "type": "people",
+  },
+]
+`;
+
 exports[`ArraySchema denormalization (immutable) returns the input value if is null 1`] = `
 Taco {
   "fillings": null,