enhance: Switch denormalize paths back to object

ntucker · ntucker · commit 954ed98f4748 · 2025-05-29T09:10:10.000+01:00
diff --git a/packages/core/src/controller/Controller.ts b/packages/core/src/controller/Controller.ts
@@ -650,7 +650,7 @@ function entityExpiresAt(
   },
 ) {
   let expiresAt = Infinity;
-  for (const [key, pk] of paths) {
+  for (const { key, pk } of paths) {
     const entityExpiry = entitiesMeta[key]?.[pk]?.expiresAt;
     // expiresAt will always resolve to false with any comparison
     if (entityExpiry < expiresAt) expiresAt = entityExpiry;
diff --git a/packages/core/src/state/GCPolicy.ts b/packages/core/src/state/GCPolicy.ts
@@ -46,7 +46,7 @@ export class GCPolicy implements GCInterface {
       if (key)
         this.endpointCount.set(key, (this.endpointCount.get(key) ?? 0) + 1);
       paths.forEach(path => {
-        const [key, pk] = path;
+        const { key, pk } = path;
         if (!this.entityCount.has(key)) {
           this.entityCount.set(key, new Map<string, number>());
         }
@@ -69,7 +69,7 @@ export class GCPolicy implements GCInterface {
           }
         }
         paths.forEach(path => {
-          const [key, pk] = path;
+          const { key, pk } = path;
           if (!this.entityCount.has(key)) {
             return;
           }
@@ -133,9 +133,9 @@ export class GCPolicy implements GCInterface {
     const nextEntitiesQ: EntityPath[] = [];
     for (const path of this.entitiesQ) {
       if (
-        !this.entityCount.get(path[0])?.has(path[1]) &&
+        !this.entityCount.get(path.key)?.has(path.pk) &&
         this.expiresAt(
-          state.entitiesMeta[path[0]]?.[path[1]] ?? {
+          state.entitiesMeta[path.key]?.[path.pk] ?? {
             fetchedAt: 0,
             date: 0,
             expiresAt: 0,
diff --git a/packages/core/src/state/__tests__/GCPolicy.test.ts b/packages/core/src/state/__tests__/GCPolicy.test.ts
@@ -25,7 +25,7 @@ describe('GCPolicy', () => {
 
   it('should increment and decrement endpoint and entity counts', () => {
     const key = 'testEndpoint';
-    const paths: EntityPath[] = [['testEntity', '1']];
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const countRef = gcPolicy.createCountRef({ key, paths });
 
     const decrement = countRef();
@@ -39,7 +39,7 @@ describe('GCPolicy', () => {
 
   it('should dispatch GC action once no ref counts and is expired', () => {
     const key = 'testEndpoint';
-    const paths: EntityPath[] = [['testEntity', '1']];
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const state = {
       meta: {
         testEndpoint: {
@@ -74,14 +74,14 @@ describe('GCPolicy', () => {
     gcPolicy['runSweep']();
     expect(controller.dispatch).toHaveBeenCalledWith({
       type: GC,
-      entities: [['testEntity', '1']],
+      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[] = [['testEntity', '1']];
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const state = {
       meta: {
         testEndpoint: {
@@ -117,14 +117,14 @@ describe('GCPolicy', () => {
     gcPolicy['runSweep']();
     expect(controller.dispatch).toHaveBeenCalledWith({
       type: GC,
-      entities: [['testEntity', '1']],
+      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[] = [['testEntity', '1']];
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const state = {
       meta: {},
       entitiesMeta: {},
@@ -145,15 +145,15 @@ describe('GCPolicy', () => {
     gcPolicy['runSweep']();
     expect(controller.dispatch).toHaveBeenCalledWith({
       type: GC,
-      entities: [['testEntity', '1']],
+      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[] = [['testEntity', '1']];
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const futureTime = Date.now() + 1000;
     const state = {
       meta: {
@@ -211,7 +211,7 @@ describe('GCPolicy', () => {
 
     expect(controller.dispatch).toHaveBeenCalledWith({
       type: GC,
-      entities: [['testEntity', '1']],
+      entities: [{ key: 'testEntity', pk: '1' }],
       endpoints: ['testEndpoint'],
     });
 
@@ -223,7 +223,7 @@ describe('GCPolicy', () => {
     gcPolicy = new GCPolicy({ expiresAt: () => 0 });
     gcPolicy.init(controller);
     const key = 'testEndpoint';
-    const paths: EntityPath[] = [['testEntity', '1']];
+    const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const futureTime = Date.now() + 1000;
     const state = {
       meta: {
diff --git a/packages/core/src/state/__tests__/reducer.ts b/packages/core/src/state/__tests__/reducer.ts
@@ -720,8 +720,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'],
       };
@@ -739,8 +739,8 @@ describe('reducer', () => {
       const action: GCAction = {
         type: GC,
         entities: [
-          [Article.key, '100000000'],
-          ['sillythings', '10'],
+          { key: Article.key, pk: '100000000' },
+          { key: 'sillythings', pk: '10' },
         ],
         endpoints: [],
       };
diff --git a/packages/core/src/state/reducer/createReducer.ts b/packages/core/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).entitiesMeta[key]?.[pk];
         });
diff --git a/packages/endpoint/src/interface.ts b/packages/endpoint/src/interface.ts
@@ -113,7 +113,12 @@ export interface Visit {
   creating?: boolean;
 }
 
-export type EntityPath = [key: string, pk: string];
+/** Used in denormalize. Lookup to find an entity in the store table */
+export interface EntityPath {
+  key: string;
+  pk: string;
+}
+
 export type IndexPath = [key: string, index: string, value: string];
 export type EntitiesPath = [key: string];
 
@@ -124,11 +129,11 @@ export interface CheckLoop {
 
 /** Get all normalized entities of one type from store */
 export interface GetEntities {
-  (...path: EntitiesPath): { readonly [pk: string]: any } | undefined;
+  (key: string): { readonly [pk: string]: any } | undefined;
 }
 /** Get normalized Entity from store */
 export interface GetEntity {
-  (...path: EntityPath): any;
+  (key: string, pk: string): any;
 }
 /** Get PK using an Entity Index */
 export interface GetIndex {
diff --git a/packages/endpoint/src/schemas/__tests__/All.test.ts b/packages/endpoint/src/schemas/__tests__/All.test.ts
@@ -5,7 +5,7 @@ import {
   MemoCache,
   denormalize,
   INVALID,
-  Delegate,
+  PlainDelegate,
 } from '@data-client/normalizr';
 import { DelegateImmutable } from '@data-client/normalizr/immutable';
 import { IDEntity } from '__tests__/new';
@@ -103,7 +103,7 @@ describe.each([[]])(`${schema.All.name} normalization (%s)`, () => {
 });
 
 describe.each([
-  ['direct', <T>(data: T) => data, <T>(data: T) => data, Delegate],
+  ['direct', <T>(data: T) => data, <T>(data: T) => data, PlainDelegate],
   [
     'immutable',
     fromJSState,
diff --git a/packages/endpoint/src/schemas/__tests__/Query.test.ts b/packages/endpoint/src/schemas/__tests__/Query.test.ts
@@ -1,5 +1,5 @@
 // eslint-env jest
-import { MemoCache, Delegate } from '@data-client/normalizr';
+import { MemoCache, PlainDelegate } from '@data-client/normalizr';
 import { DelegateImmutable } from '@data-client/normalizr/immutable';
 import { useQuery, useSuspense, __INTERNAL__ } from '@data-client/react';
 import { RestEndpoint } from '@data-client/rest';
@@ -27,7 +27,7 @@ class User extends IDEntity {
 }
 
 describe.each([
-  ['direct', <T>(data: T) => data, <T>(data: T) => data, Delegate],
+  ['direct', <T>(data: T) => data, <T>(data: T) => data, PlainDelegate],
   [
     'immutable',
     fromJSState,
diff --git a/packages/normalizr/src/__tests__/WeakDependencyMap.test.ts b/packages/normalizr/src/__tests__/WeakDependencyMap.test.ts
@@ -20,9 +20,9 @@ describe('WeakDependencyMap', () => {
     },
   };
   const getEntity = getEntities(state);
-  const depA = { path: ['A', '1'] as EntityPath, entity: a };
-  const depB = { path: ['B', '2'] as EntityPath, entity: b };
-  const depC = { path: ['C', '3'] as EntityPath, entity: c };
+  const depA = { path: { key: 'A', pk: '1' }, entity: a };
+  const depB = { path: { key: 'B', pk: '2' }, entity: b };
+  const depC = { path: { key: 'C', pk: '3' }, entity: c };
 
   it('should construct', () => {
     const wem = new WeakDependencyMap<EntityPath>();
diff --git a/packages/normalizr/src/__tests__/__snapshots__/MemoCache.ts.snap b/packages/normalizr/src/__tests__/__snapshots__/MemoCache.ts.snap
@@ -16,10 +16,10 @@ exports[`MemoCache query (direct) works with pk 1`] = `
     "username": "m",
   },
   "paths": [
-    [
-      "Cat",
-      "1",
-    ],
+    {
+      "key": "Cat",
+      "pk": "1",
+    },
   ],
 }
 `;
@@ -40,10 +40,10 @@ exports[`MemoCache query (immutable) works with pk 1`] = `
     "username": "m",
   },
   "paths": [
-    [
-      "Cat",
-      "1",
-    ],
+    {
+      "key": "Cat",
+      "pk": "1",
+    },
   ],
 }
 `;
diff --git a/packages/normalizr/src/denormalize/getEntities.ts b/packages/normalizr/src/denormalize/getEntities.ts
@@ -8,9 +8,9 @@ export function getEntities<K extends object>(
   const entityIsImmutable = isImmutable(state);
 
   if (entityIsImmutable) {
-    return (path: EntityPath) => state.getIn(path);
+    return ({ key, pk }: EntityPath) => state.getIn([key, pk]);
   } else {
-    return ([key, pk]: EntityPath) => state[key]?.[pk];
+    return ({ key, pk }: EntityPath) => state[key]?.[pk];
   }
 }
 
diff --git a/packages/normalizr/src/denormalize/unvisit.ts b/packages/normalizr/src/denormalize/unvisit.ts
@@ -18,7 +18,8 @@ const getUnvisitEntity = (
     entityOrId: Record<string, any> | string,
   ): object | undefined | typeof INVALID {
     const inputIsId = typeof entityOrId !== 'object';
-    const entity = inputIsId ? getEntity([schema.key, entityOrId]) : entityOrId;
+    const entity =
+      inputIsId ? getEntity({ key: schema.key, pk: entityOrId }) : entityOrId;
     if (typeof entity === 'symbol') {
       return schema.denormalize(entity, args, unvisit);
     }
diff --git a/packages/normalizr/src/interface.ts b/packages/normalizr/src/interface.ts
@@ -99,10 +99,15 @@ export interface Visit {
   (schema: any, value: any, parent: any, key: any, args: readonly any[]): any;
 }
 
-export type EntityPath = [key: string, pk: string];
+/** Used in denormalize. Lookup to find an entity in the store table */
+export interface EntityPath {
+  key: string;
+  pk: string;
+}
+
 export type IndexPath = [key: string, index: string, value: string];
 export type EntitiesPath = [key: string];
-export type QueryPath = IndexPath | EntityPath | EntitiesPath;
+export type QueryPath = IndexPath | [key: string, pk: string] | EntitiesPath;
 
 /** Returns true if a circular reference is found */
 export interface CheckLoop {
@@ -111,11 +116,11 @@ export interface CheckLoop {
 
 /** Get all normalized entities of one type from store */
 export interface GetEntities {
-  (...path: EntitiesPath): { readonly [pk: string]: any } | undefined;
+  (key: string): { readonly [pk: string]: any } | undefined;
 }
 /** Get normalized Entity from store */
 export interface GetEntity {
-  (...path: EntityPath): any;
+  (key: string, pk: string): any;
 }
 /** Get PK using an Entity Index */
 export interface GetIndex {
diff --git a/packages/normalizr/src/memo/BaseDelegate.ts b/packages/normalizr/src/memo/BaseDelegate.ts
@@ -1,7 +1,6 @@
 import type { Dep } from './WeakDependencyMap.js';
 import { INVALID } from '../denormalize/symbol.js';
 import type {
-  EntityPath,
   QueryPath,
   IndexPath,
   EntitiesPath,
@@ -25,7 +24,7 @@ export abstract class BaseDelegate {
   }
 
   abstract getEntities(...path: EntitiesPath): object | undefined;
-  abstract getEntity(...path: EntityPath): object | undefined;
+  abstract getEntity(key: string, pk: string): object | undefined;
   abstract getIndex(...path: IndexPath): object | undefined;
   abstract getIndexEnd(entity: any, value: string): string | undefined;
 
@@ -42,7 +41,7 @@ export abstract class BaseDelegate {
         dependencies.push({ path, entity });
         return base.getIndexEnd(entity, path[2]);
       },
-      getEntity(...path: EntityPath) {
+      getEntity(...path: [key: string, pk: string]) {
         const entity = base.getEntity(...path);
         dependencies.push({ path, entity });
         return entity;
diff --git a/packages/normalizr/src/memo/Delegate.immutable.ts b/packages/normalizr/src/memo/Delegate.immutable.ts
@@ -22,7 +22,7 @@ export class DelegateImmutable extends BaseDelegate {
     return this.entities.get(key)?.toJS();
   }
 
-  getEntity(...path: EntityPath): any {
+  getEntity(...path: [key: string, pk: string]): any {
     return this.entities.getIn(path);
   }
 
diff --git a/packages/normalizr/src/memo/globalCache.ts b/packages/normalizr/src/memo/globalCache.ts
@@ -58,7 +58,7 @@ export default class GlobalCache implements Cache {
       else {
         const trackingIndex = this.dependencies.length;
         cycleCacheKey.set(pk, trackingIndex);
-        this.dependencies.push({ path: [key, pk], entity });
+        this.dependencies.push({ path: { key, pk }, entity });
 
         /** NON-GLOBAL_CACHE CODE */
         computeValue(localCacheKey);
@@ -87,7 +87,7 @@ export default class GlobalCache implements Cache {
         this.cycleIndex = cycleCacheKey.get(pk)!;
       } else {
         // with no cycle, globalCacheEntry will have already been set
-        this.dependencies.push({ path: [key, pk], entity });
+        this.dependencies.push({ path: { key, pk }, entity });
       }
     }
     return localCacheKey.get(pk);
@@ -125,7 +125,7 @@ export default class GlobalCache implements Cache {
       // we want to do this before we add our 'input' entry
       paths = this.paths();
       // for the first entry, `path` is ignored so empty members is fine
-      this.dependencies.unshift({ path: ['', ''], entity: input });
+      this.dependencies.unshift({ path: { key: '', pk: '' }, entity: input });
       this.resultCache.set(this.dependencies, data);
     } else {
       paths.shift();

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`// eslint-env jest`
`2`		`-import { MemoCache, Delegate } from '@data-client/normalizr';`
	`2`	`+import { MemoCache, PlainDelegate } from '@data-client/normalizr';`
`3`	`3`	`import { DelegateImmutable } from '@data-client/normalizr/immutable';`
`4`	`4`	`import { useQuery, useSuspense, __INTERNAL__ } from '@data-client/react';`
`5`	`5`	`import { RestEndpoint } from '@data-client/rest';`
`@@ -27,7 +27,7 @@ class User extends IDEntity {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`describe.each([`
`30`		`- ['direct', <T>(data: T) => data, <T>(data: T) => data, Delegate],`
	`30`	`+ ['direct', <T>(data: T) => data, <T>(data: T) => data, PlainDelegate],`
`31`	`31`	`[`
`32`	`32`	`'immutable',`
`33`	`33`	`fromJSState,`