enhance: Hoist ImmutableJS vs Pojo split to import-time (#3468)

Author: ntucker

.changeset/big-impalas-tap.md

@@ -0,0 +1,28 @@
+---
+'@data-client/normalizr': patch
+---
+
+Add /imm exports path for handling ImmutableJS state
+
+#### MemoCache
+
+```ts
+import { MemoCache } from '@data-client/normalizr';
+import { MemoPolicy } from '@data-client/normalizr/imm';
+
+const memo = new MemoCache(MemoPolicy);
+
+// entities is an ImmutableJS Map
+const value = MemoCache.denormalize(Todo, '1', entities);
+```
+
+#### denormalize
+
+non-memoized denormalize
+
+```ts
+import { denormalize } from '@data-client/normalizr/imm';
+
+// entities is an ImmutableJS Map
+const value = denormalize(Todo, '1', entities);
+```

.changeset/legal-files-fly.md

@@ -0,0 +1,24 @@
+---
+'@data-client/normalizr': minor
+---
+
+BREAKING: denormalize no longer detects ImmutableJS state
+
+Use `/imm` exports to handle ImmutableJS state
+
+#### Before
+
+```ts
+import { MemoCache, denormalize } from '@data-client/normalizr';
+
+const memo = new MemoCache();
+```
+
+#### After
+
+```ts
+import { MemoCache } from '@data-client/normalizr';
+import { MemoPolicy, denormalize } from '@data-client/normalizr/imm';
+
+const memo = new MemoCache(MemoPolicy);
+```

.changeset/proud-taxes-bake.md

@@ -0,0 +1,8 @@
+---
+'@data-client/normalizr': minor
+'@data-client/endpoint': minor
+---
+
+delegate.getEntity(this.key) -> delegate.getEntities(this.key)
+
+This applies to both schema.queryKey and schema.normalize method delegates.

.changeset/ten-lions-retire.md

@@ -0,0 +1,9 @@
+---
+'@data-client/normalizr': patch
+'@data-client/core': patch
+'@data-client/react': patch
+---
+
+Improve performance of get/denormalize for small responses
+
+- 10-20% performance improvement due to removing immutablejs check for every call

packages/core/src/controller/Controller.ts

@@ -544,8 +544,6 @@ export default class Controller<
       };
     }
 
-    // second argument is false if any entities are missing
-
     const { data, paths } = this.memo.denormalize(
       schema,
       input,
@@ -652,7 +650,7 @@ function entityExpiresAt(
   },
 ) {
   let expiresAt = Infinity;
-  for (const { pk, key } 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;

packages/core/src/state/GCPolicy.ts

@@ -46,11 +46,12 @@ export class GCPolicy implements GCInterface {
       if (key)
         this.endpointCount.set(key, (this.endpointCount.get(key) ?? 0) + 1);
       paths.forEach(path => {
-        if (!this.entityCount.has(path.key)) {
-          this.entityCount.set(path.key, new Map<string, number>());
+        const { key, pk } = path;
+        if (!this.entityCount.has(key)) {
+          this.entityCount.set(key, new Map<string, number>());
         }
-        const instanceCount = this.entityCount.get(path.key)!;
-        instanceCount.set(path.pk, (instanceCount.get(path.pk) ?? 0) + 1);
+        const instanceCount = this.entityCount.get(key)!;
+        instanceCount.set(pk, (instanceCount.get(pk) ?? 0) + 1);
       });
 
       // decrement
@@ -68,18 +69,19 @@ export class GCPolicy implements GCInterface {
           }
         }
         paths.forEach(path => {
-          if (!this.entityCount.has(path.key)) {
+          const { key, pk } = path;
+          if (!this.entityCount.has(key)) {
             return;
           }
-          const instanceCount = this.entityCount.get(path.key)!;
-          const entityCount = instanceCount.get(path.pk)!;
+          const instanceCount = this.entityCount.get(key)!;
+          const entityCount = instanceCount.get(pk)!;
           if (entityCount !== undefined) {
             if (entityCount <= 1) {
-              instanceCount.delete(path.pk);
+              instanceCount.delete(pk);
               // queue for cleanup
               this.entitiesQ.push(path);
             } else {
-              instanceCount.set(path.pk, entityCount - 1);
+              instanceCount.set(pk, entityCount - 1);
             }
           }
         });

packages/endpoint/src/index.ts

@@ -17,21 +17,7 @@ export { default as Entity } from './schemas/Entity.js';
 export { default as EntityMixin } from './schemas/EntityMixin.js';
 export type { IEntityClass, IEntityInstance } from './schemas/EntityTypes.js';
 export { default as validateRequired } from './validateRequired.js';
-export type {
-  EndpointInterface,
-  ReadEndpoint,
-  MutateEndpoint,
-  Schema,
-  IQueryDelegate,
-  INormalizeDelegate,
-  SnapshotInterface,
-  ExpiryStatusInterface,
-  SchemaSimple,
-  SchemaClass,
-  PolymorphicInterface,
-  Queryable,
-  Mergeable,
-} from './interface.js';
+export * from './interface.js';
 export type { EntityFields } from './schemas/EntityFields.js';
 export type {
   AbstractInstanceType,

packages/endpoint/src/interface.ts

@@ -113,24 +113,37 @@ export interface Visit {
   creating?: boolean;
 }
 
+/** 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];
+
 /** Returns true if a circular reference is found */
 export interface CheckLoop {
   (entityKey: string, pk: string, input: object): boolean;
 }
 
-/** Get Array of entities with map function applied */
+/** Get all normalized entities of one type from store */
+export interface GetEntities {
+  (key: string): { readonly [pk: string]: any } | undefined;
+}
+/** Get normalized Entity from store */
 export interface GetEntity {
-  (entityKey: string | symbol): { readonly [pk: string]: any } | undefined;
-  (entityKey: string | symbol, pk: string | number): any;
+  (key: string, pk: string): any;
 }
 /** Get PK using an Entity Index */
 export interface GetIndex {
   /** getIndex('User', 'username', 'ntucker') */
-  (entityKey: string, field: string, value: string): string | undefined;
+  (...path: IndexPath): string | undefined;
 }
 
 /** Accessors to the currently processing state while building query */
 export interface IQueryDelegate {
+  getEntities: GetEntities;
   getEntity: GetEntity;
   getIndex: GetIndex;
   /** Return to consider results invalid */
@@ -141,6 +154,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;
   /** 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

@@ -26,7 +26,7 @@ export default class AllSchema<
 
   queryKey(args: any, unvisit: any, delegate: IQueryDelegate): any {
     if (this.isSingleSchema) {
-      const entitiesEntry = delegate.getEntity(this.schema.key);
+      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(
@@ -36,7 +36,7 @@ export default class AllSchema<
     let found = false;
     const list = Object.values(this.schema as Record<string, any>).flatMap(
       (schema: EntityInterface) => {
-        const entitiesEntry = delegate.getEntity(schema.key);
+        const entitiesEntry = delegate.getEntities(schema.key);
         if (entitiesEntry === undefined) return [];
         found = true;
         return Object.entries(entitiesEntry).map(([key, entity]) => ({

packages/endpoint/src/schemas/Collection.ts

@@ -219,9 +219,9 @@ export default class CollectionSchema<
 
   queryKey(args: Args, unvisit: unknown, delegate: IQueryDelegate): any {
     if (this.argsKey) {
-      const id = this.pk(undefined, undefined, '', args);
+      const pk = this.pk(undefined, undefined, '', args);
       // ensure this actually has entity or we shouldn't try to use it in our query
-      if (delegate.getEntity(this.key, id)) return id;
+      if (delegate.getEntity(this.key, pk)) return pk;
     }
   }
 
@@ -326,7 +326,7 @@ function normalizeCreate(
   // parent is args when not nested
   const filterCollections = (this.createCollectionFilter as any)(...args);
   // add to any collections that match this
-  const entities = delegate.getEntity(this.key);
+  const entities = delegate.getEntities(this.key);
   if (entities)
     Object.keys(entities).forEach(collectionPk => {
       if (!filterCollections(JSON.parse(collectionPk))) return;