feat: Add schema.Query

examples/benchmark/core.js

@@ -137,7 +137,7 @@ export default function addReducerSuite(suite) {
         }
       })
       .add('getResponse Query-sorted', () => {
-        return controller.getResponse(ProjectQuerySorted, cachedState);
+        return controller.query(ProjectQuerySorted, cachedState);
       })
       .add('getResponse Collection', () => {
         return controllerCollection.getResponse(

examples/benchmark/schemas.js

@@ -1,4 +1,4 @@
-import { Entity, schema, Query } from './dist/index.js';
+import { Entity, schema } from './dist/index.js';
 
 export class BuildTypeDescription extends Entity {
   id = '';
@@ -100,7 +100,7 @@ export const ProjectSchemaMixin = {
 export const ProjectQuery = {
   project: new schema.All(ProjectWithBuildTypesDescription),
 };
-export const ProjectQuerySorted = new Query(
+export const ProjectQuerySorted = new schema.Query(
   new schema.All(ProjectWithBuildTypesDescription),
   entries => {
     return [...entries].sort((a, b) => a.internalId - b.internalId);

examples/coin-app/src/resources/Currency.ts

@@ -1,4 +1,4 @@
-import { Entity, Query, createResource, schema } from '@data-client/rest';
+import { Entity, createResource, schema } from '@data-client/rest';
 
 import { Stats } from './Stats';
 
@@ -61,7 +61,7 @@ export const CurrencyResource = createResource({
 interface Args {
   type?: string;
 }
-export const queryCurrency = new Query(
+export const queryCurrency = new schema.Query(
   new schema.All(Currency),
   (entries, { type = 'crypto' }: Args) => {
     let sorted = entries.filter(

examples/coin-app/src/resources/Product.ts

@@ -1,4 +1,4 @@
-import { Entity, Query, createResource, schema } from '@data-client/rest';
+import { Entity, createResource, schema } from '@data-client/rest';
 
 import { Stats } from './Stats';
 
@@ -34,7 +34,7 @@ export const ProductResource = createResource({
 interface Args {
   quote_currency?: string;
 }
-export const queryProduct = new Query(
+export const queryProduct = new schema.Query(
   new schema.All(Product),
   (entries, { quote_currency }: Args) => {
     let sorted = entries.filter(product => product.stats);

examples/nextjs/resources/TodoResource.ts

@@ -1,4 +1,4 @@
-import { Query, schema } from '@data-client/rest';
+import { schema } from '@data-client/rest';
 
 import {
   createPlaceholderResource,
@@ -20,7 +20,7 @@ export const TodoResource = createPlaceholderResource({
   searchParams: {} as { userId?: string | number } | undefined,
 });
 
-export const queryRemainingTodos = new Query(
+export const queryRemainingTodos = new schema.Query(
   TodoResource.getList.schema,
   (entries) => entries && entries.filter((todo) => !todo.completed).length,
 );

examples/todo-app/src/pages/Home/TodoStats.tsx

@@ -1,8 +1,8 @@
-import { useCache } from '@data-client/react';
+import { useQuery } from '@data-client/react';
 import { queryRemainingTodos } from 'resources/TodoResource';
 
 export default function TodoStats({ userId }: { userId?: number }) {
-  const remaining = useCache(queryRemainingTodos, { userId });
+  const remaining = useQuery(queryRemainingTodos, { userId });
 
   return <div>{remaining} tasks remaining</div>;
 }

examples/todo-app/src/resources/TodoResource.ts

@@ -1,4 +1,4 @@
-import { Query, schema } from '@data-client/rest';
+import { schema } from '@data-client/rest';
 
 import {
   createPlaceholderResource,
@@ -20,7 +20,7 @@ export const TodoResource = createPlaceholderResource({
   searchParams: {} as { userId?: string | number } | undefined,
 });
 
-export const queryRemainingTodos = new Query(
+export const queryRemainingTodos = new schema.Query(
   TodoResource.getList.schema,
   (entries) => entries && entries.filter((todo) => !todo.completed).length,
 );

packages/core/src/controller/Controller.ts

@@ -397,7 +397,7 @@ export default class Controller<
     let results;
     let resultCache: ResultCache;
     if (cacheResults === undefined && endpoint.schema !== undefined) {
-      if (!this.globalCache.inputEndpointCache[key])
+      if (!this.globalCache.inputEndpointCache[key] || true)
         this.globalCache.inputEndpointCache[key] = inferResults(
           endpoint.schema,
           args,
@@ -473,7 +473,7 @@ export default class Controller<
     const querySchemaCache = this.globalCache.queries.get(schema) as {
       [key: string]: unknown;
     };
-    if (!querySchemaCache[key])
+    if (!querySchemaCache[key] || true)
       querySchemaCache[key] = inferResults(
         schema,
         args,

packages/endpoint/src/index.ts

@@ -50,5 +50,4 @@ export type {
 export { default as Endpoint, ExtendableEndpoint } from './endpoint.js';
 export type { KeyofEndpointInstance } from './endpoint.js';
 export * from './indexEndpoint.js';
-export * from './queryEndpoint.js';
 export { default as AbortOptimistic } from './AbortOptimistic.js';

packages/endpoint/src/interface.ts

@@ -24,7 +24,7 @@ export type Serializable<
   T extends { toJSON(): string } = { toJSON(): string },
 > = (value: any) => T;
 
-export interface SchemaSimple<T = any, Args extends any[] = any[]> {
+export interface SchemaSimple<T = any, Args extends readonly any[] = any[]> {
   normalize(
     input: any,
     parent: any,

packages/endpoint/src/schema.d.ts

@@ -29,14 +29,15 @@ import {
   PKClass,
 } from './schemas/EntitySchema.js';
 import { default as Invalidate } from './schemas/Invalidate.js';
+import { default as Query } from './schemas/Query.js';
 import type {
   CollectionConstructor,
   SchemaAttributeFunction,
   SchemaFunction,
   UnionResult,
 } from './schemaTypes.js';
 
-export { EntityMap, Invalidate };
+export { EntityMap, Invalidate, Query };
 
 export type { SchemaClass };
 

packages/endpoint/src/schema.js

@@ -7,3 +7,4 @@ export { default as Object } from './schemas/Object.js';
 export { default as Invalidate } from './schemas/Invalidate.js';
 export { default as Collection } from './schemas/Collection.js';
 export { default as Entity } from './schemas/EntitySchema.js';
+export { default as Query } from './schemas/Query.js';

packages/endpoint/src/schemas/Query.ts

@@ -0,0 +1,58 @@
+import type {
+  EntityTable,
+  NormalizedIndex,
+  Queryable,
+  SchemaSimple,
+} from '../interface.js';
+import type { Denormalize, SchemaArgs } from '../normal.js';
+
+/**
+ * Programmatic cache reading
+ * @see https://dataclient.io/rest/api/Query
+ */
+export default class Query<
+  S extends Queryable,
+  P extends readonly unknown[] = SchemaArgs<S>,
+  R = Denormalize<S>,
+> implements SchemaSimple<R | undefined, P>
+{
+  declare schema: S;
+  declare process: (entries: Denormalize<S>, ...args: P) => R;
+
+  constructor(schema: S, process?: (entries: Denormalize<S>, ...args: P) => R) {
+    this.schema = schema;
+    if (process) this.process = process;
+    // allows for inheritance overrides
+    else if (!this.process)
+      this.process = ((entries: Denormalize<S>) => entries) as any;
+  }
+
+  normalize(...args: any) {
+    return (this.schema as any).normalize(...args);
+  }
+
+  denormalize(input: {}, args: P, unvisit: any): R | undefined {
+    const value = unvisit(input, this.schema);
+    return typeof value === 'symbol' ? undefined : this.process(value, ...args);
+  }
+
+  infer(
+    args: P,
+    indexes: any,
+    recurse: (
+      schema: any,
+      args: any,
+      indexes: NormalizedIndex,
+      entities: EntityTable,
+    ) => any,
+    entities: EntityTable,
+  ) {
+    return recurse(this.schema, args, indexes, entities);
+  }
+
+  declare _denormalizeNullable: (
+    input: {},
+    args: readonly any[],
+    unvisit: (input: any, schema: any) => any,
+  ) => R | undefined;
+}

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

@@ -88,7 +88,6 @@ describe(`${schema.Collection.name} normalization`, () => {
         () => undefined,
         {},
         {},
-        // @ts-expect-error
         [],
       );
     }

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

@@ -4,7 +4,7 @@ import { IDEntity } from '__tests__/new';
 import { fromJS } from 'immutable';
 
 import { denormalizeSimple } from './denormalize';
-import { schema, Query, Denormalize, DenormalizeNullable } from '../..';
+import { schema, DenormalizeNullable } from '../..';
 
 let dateSpy: jest.SpyInstance<number, []>;
 beforeAll(() => {
@@ -43,9 +43,9 @@ describe.each([
   }
 
   describe.each(SCHEMA_CASES)(
-    `${Query.name} denormalization (%s schema)`,
+    `${schema.Query.name} denormalization (%s schema)`,
     (_, usersSchema) => {
-      const sortedUsers = new Query(
+      const sortedUsers = new schema.Query(
         usersSchema,
         ({ results }, { asc } = { asc: false }) => {
           if (!results) return results;
@@ -71,10 +71,10 @@ describe.each([
             ],
           },
         };
-        const users: DenormalizeNullable<typeof sortedUsers.schema> | symbol =
+        const users: DenormalizeNullable<typeof sortedUsers> | symbol =
           denormalize(
-            inferResults(sortedUsers.schema, [], {}, entities),
-            sortedUsers.schema,
+            inferResults(sortedUsers, [], {}, entities),
+            sortedUsers,
             createInput(entities),
           );
         expect(users).not.toEqual(expect.any(Symbol));
@@ -99,8 +99,8 @@ describe.each([
         };
         expect(
           denormalize(
-            inferResults(sortedUsers.schema, [{ asc: true }], {}, entities),
-            sortedUsers.schema,
+            inferResults(sortedUsers, [{ asc: true }], {}, entities),
+            sortedUsers,
             createInput(entities),
             {},
             new WeakEntityMap(),
@@ -116,19 +116,19 @@ describe.each([
             2: { id: '2', name: 'Jake' },
           },
         };
-        const input = inferResults(sortedUsers.schema, [], {}, entities);
+        const input = inferResults(sortedUsers, [], {}, entities);
 
         const value = denormalize(
           createInput(input),
-          sortedUsers.schema,
+          sortedUsers,
           createInput(entities),
         );
 
         expect(createOutput(value)).toEqual(undefined);
       });
 
       test('denormalize aggregates', () => {
-        const userCountByAdmin = new Query(
+        const userCountByAdmin = new schema.Query(
           usersSchema,
           ({ results }, { isAdmin }: { isAdmin?: boolean } = {}) => {
             if (isAdmin === undefined) return results.length;
@@ -155,39 +155,29 @@ describe.each([
           },
         };
         const totalCount:
-          | DenormalizeNullable<typeof userCountByAdmin.schema>
+          | DenormalizeNullable<typeof userCountByAdmin>
           | symbol = denormalize(
-          inferResults(userCountByAdmin.schema, [], {}, entities),
-          userCountByAdmin.schema,
+          inferResults(userCountByAdmin, [], {}, entities),
+          userCountByAdmin,
           createInput(entities),
         );
         expect(totalCount).toBe(4);
         const nonAdminCount:
-          | DenormalizeNullable<typeof userCountByAdmin.schema>
+          | DenormalizeNullable<typeof userCountByAdmin>
           | symbol = denormalize(
-          inferResults(
-            userCountByAdmin.schema,
-            [{ isAdmin: false }],
-            {},
-            entities,
-          ),
-          userCountByAdmin.schema,
+          inferResults(userCountByAdmin, [{ isAdmin: false }], {}, entities),
+          userCountByAdmin,
           createInput(entities),
           {},
           new WeakEntityMap(),
           [{ isAdmin: false }],
         );
         expect(nonAdminCount).toBe(3);
         const adminCount:
-          | DenormalizeNullable<typeof userCountByAdmin.schema>
+          | DenormalizeNullable<typeof userCountByAdmin>
           | symbol = denormalize(
-          inferResults(
-            userCountByAdmin.schema,
-            [{ isAdmin: true }],
-            {},
-            entities,
-          ),
-          userCountByAdmin.schema,
+          inferResults(userCountByAdmin, [{ isAdmin: true }], {}, entities),
+          userCountByAdmin,
           createInput(entities),
           {},
           new WeakEntityMap(),
@@ -206,7 +196,7 @@ describe.each([
 });
 
 describe('top level schema', () => {
-  const sortedUsers = new Query(
+  const sortedUsers = new schema.Query(
     new schema.Collection([User]),
     (results, { asc } = { asc: false }) => {
       if (!results) return results;
@@ -228,12 +218,11 @@ describe('top level schema', () => {
         [new schema.Collection([User]).pk({}, undefined, '', [])]: [1, 2, 3, 4],
       },
     };
-    const users: DenormalizeNullable<typeof sortedUsers.schema> | symbol =
-      denormalize(
-        inferResults(sortedUsers.schema, [], {}, entities),
-        sortedUsers.schema,
-        entities,
-      );
+    const users: DenormalizeNullable<typeof sortedUsers> | symbol = denormalize(
+      inferResults(sortedUsers, [], {}, entities),
+      sortedUsers,
+      entities,
+    );
     expect(users).not.toEqual(expect.any(Symbol));
     if (typeof users === 'symbol') return;
     expect(users && users[0].name).toBe('Zeta');
@@ -247,9 +236,9 @@ describe('top level schema', () => {
         2: { id: '2', name: 'Jake' },
       },
     };
-    const input = inferResults(sortedUsers.schema, [], {}, entities);
+    const input = inferResults(sortedUsers, [], {}, entities);
 
-    const value = denormalize(input, sortedUsers.schema, entities);
+    const value = denormalize(input, sortedUsers, entities);
 
     expect(value).toEqual(undefined);
   });