enhance: MemoCache.query returns {data, paths} just like denormalize

Author: ntucker

.changeset/stale-socks-accept.md

@@ -0,0 +1,17 @@
+---
+'@data-client/normalizr': minor
+---
+
+MemoCache.query returns `{ data, paths }` just like denormalize
+
+#### Before
+
+```ts
+const data = this.memo.query(schema, args, state);
+```
+
+#### After
+
+```ts
+const { data } = this.memo.query(schema, args, state);
+```

packages/core/src/controller/Controller.ts

@@ -589,7 +589,8 @@ export default class Controller<
       .slice(0, rest.length - 1)
       .map(ensurePojo) as SchemaArgs<S>;
 
-    return this.memo.query(schema, args, state);
+    const { data } = this.memo.query(schema, args, state);
+    return typeof data === 'symbol' ? undefined : (data as any);
   }
 
   /**
@@ -612,27 +613,10 @@ export default class Controller<
       .slice(0, rest.length - 1)
       .map(ensurePojo) as SchemaArgs<S>;
 
-    // TODO: breaking: Switch back to this.memo.query(schema, args, state.entities as any, state.indexes) to do
-    // this logic
-    const input = this.memo.buildQueryKey(
-      schema,
-      args,
-      state,
-      JSON.stringify(args),
-    );
+    const { data, paths } = this.memo.query(schema, args, state);
 
-    if (!input) {
-      return { data: undefined, countRef: () => () => undefined };
-    }
-
-    const { data, paths } = this.memo.denormalize(
-      schema,
-      input,
-      state.entities,
-      args,
-    );
     return {
-      data: typeof data === 'symbol' ? undefined : (data as any),
+      data: typeof data === 'symbol' ? undefined : data,
       countRef: this.gcPolicy.createCountRef({ paths }),
     };
   }

packages/normalizr/src/memo/MemoCache.ts

@@ -71,15 +71,17 @@ export default class MemoCache {
     state: StateInterface,
     // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
     argsKey: string = JSON.stringify(args),
-  ): DenormalizeNullable<S> | undefined {
+  ): {
+    data: DenormalizeNullable<S> | symbol;
+    paths: EntityPath[];
+  } {
     const input = this.buildQueryKey(schema, args, state, argsKey);
 
     if (!input) {
-      return;
+      return { data: undefined as any, paths: [] };
     }
 
-    const { data } = this.denormalize(schema, input, state.entities, args);
-    return typeof data === 'symbol' ? undefined : (data as any);
+    return this.denormalize(schema, input, state.entities, args);
   }
 
   buildQueryKey<S extends Schema>(

website/src/components/Playground/editor-types/@data-client/core.d.ts

@@ -224,17 +224,20 @@ declare class MemoCache {
         paths: EntityPath[];
     };
     /** Compute denormalized form maintaining referential equality for same inputs */
-    query<S extends Schema>(schema: S, args: readonly any[], entities: Record<string, Record<string, any> | undefined> | {
-        getIn(k: string[]): any;
-    }, indexes: NormalizedIndex | {
-        getIn(k: string[]): any;
-    }, argsKey?: string): DenormalizeNullable<S> | undefined;
-    buildQueryKey<S extends Schema>(schema: S, args: readonly any[], entities: Record<string, Record<string, any> | undefined> | {
+    query<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): {
+        data: DenormalizeNullable<S> | symbol;
+        paths: EntityPath[];
+    };
+    buildQueryKey<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): NormalizeNullable<S>;
+}
+type StateInterface = {
+    entities: Record<string, Record<string, any> | undefined> | {
         getIn(k: string[]): any;
-    }, indexes: NormalizedIndex | {
+    };
+    indexes: NormalizedIndex | {
         getIn(k: string[]): any;
-    }, argsKey?: string): NormalizeNullable<S>;
-}
+    };
+};
 
 /** https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-4.html#the-noinfer-utility-type */
 type NI<T> = NoInfer<T>;

website/src/components/Playground/editor-types/@data-client/normalizr.d.ts

@@ -264,17 +264,20 @@ declare class MemoCache {
         paths: EntityPath[];
     };
     /** Compute denormalized form maintaining referential equality for same inputs */
-    query<S extends Schema>(schema: S, args: readonly any[], entities: Record<string, Record<string, any> | undefined> | {
-        getIn(k: string[]): any;
-    }, indexes: NormalizedIndex | {
-        getIn(k: string[]): any;
-    }, argsKey?: string): DenormalizeNullable<S> | undefined;
-    buildQueryKey<S extends Schema>(schema: S, args: readonly any[], entities: Record<string, Record<string, any> | undefined> | {
+    query<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): {
+        data: DenormalizeNullable<S> | symbol;
+        paths: EntityPath[];
+    };
+    buildQueryKey<S extends Schema>(schema: S, args: readonly any[], state: StateInterface, argsKey?: string): NormalizeNullable<S>;
+}
+type StateInterface = {
+    entities: Record<string, Record<string, any> | undefined> | {
         getIn(k: string[]): any;
-    }, indexes: NormalizedIndex | {
+    };
+    indexes: NormalizedIndex | {
         getIn(k: string[]): any;
-    }, argsKey?: string): NormalizeNullable<S>;
-}
+    };
+};
 
 /** https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-4.html#the-noinfer-utility-type */
 type NI<T> = NoInfer<T>;