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,
 );

examples/todo-app/typetest.ts

@@ -1,4 +1,4 @@
-import { useCache, useController, useSuspense } from '@data-client/react';
+import { useQuery, useController, useSuspense } from '@data-client/react';
 
 import {
   queryRemainingTodos,
@@ -23,7 +23,7 @@ function useTest() {
     );
   });
 
-  const remaining = useCache(queryRemainingTodos, { userId: 1 });
+  const remaining = useQuery(queryRemainingTodos, { userId: 1 });
 
   const users = useSuspense(UserResource.getList);
   users.map((user) => {

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/core/src/controller/__tests__/Controller.ts

@@ -1,9 +1,7 @@
-import { Endpoint, Entity } from '@data-client/endpoint';
 import { normalize } from '@data-client/normalizr';
 import { CoolerArticleResource } from '__tests__/new';
 import { createEntityMeta } from '__tests__/utils';
 
-import { ExpiryStatus } from '../..';
 import { initialState } from '../../state/reducer/createReducer';
 import Controller from '../Controller';
 

packages/core/src/controller/__tests__/__snapshots__/query.ts.snap

@@ -0,0 +1,87 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Controller.query() Query based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.query() Query based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.query() Query+All based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.query() Query+All based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.query() query All 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.query() query Collection based on args 1`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+]
+`;
+
+exports[`Controller.query() query Collection based on args 2`] = `
+[
+  Tacos {
+    "id": "1",
+    "type": "foo",
+  },
+  Tacos {
+    "id": "2",
+    "type": "bar",
+  },
+]
+`;
+
+exports[`Controller.query() query Entity based on pk 1`] = `
+Tacos {
+  "id": "1",
+  "type": "foo",
+}
+`;

packages/core/src/controller/__tests__/query.ts

@@ -0,0 +1,147 @@
+import { Entity, schema } from '@data-client/endpoint';
+
+import { initialState } from '../../state/reducer/createReducer';
+import Contoller from '../Controller';
+
+describe('Controller.query()', () => {
+  class Tacos extends Entity {
+    type = '';
+    id = '';
+    pk() {
+      return this.id;
+    }
+  }
+  const TacoList = new schema.Collection([Tacos]);
+  const entities = {
+    Tacos: {
+      1: { id: '1', type: 'foo' },
+      2: { id: '2', type: 'bar' },
+    },
+    [TacoList.key]: {
+      [TacoList.pk(undefined, undefined, '', [{ type: 'foo' }])]: ['1'],
+      [TacoList.pk(undefined, undefined, '', [{ type: 'bar' }])]: ['2'],
+      [TacoList.pk(undefined, undefined, '', [])]: ['1', '2'],
+    },
+  };
+
+  it('query Entity based on pk', () => {
+    const controller = new Contoller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const taco = controller.query(Tacos, { id: '1' }, state);
+    expect(taco).toBeDefined();
+    expect(taco).toBeInstanceOf(Tacos);
+    expect(taco).toMatchSnapshot();
+    const taco2 = controller.query(Tacos, { id: '2' }, state);
+    expect(taco2).toBeDefined();
+    expect(taco2).toBeInstanceOf(Tacos);
+    expect(taco2).not.toEqual(taco);
+    // should maintain referential equality
+    expect(taco).toBe(controller.query(Tacos, { id: '1' }, state));
+
+    // @ts-expect-error
+    () => controller.query(Tacos, { id: { bob: 5 } }, state);
+    // @ts-expect-error
+    expect(controller.query(Tacos, 5, state)).toBeUndefined();
+    // @ts-expect-error
+    () => controller.query(Tacos, { doesnotexist: 5 }, state);
+  });
+
+  it('query Collection based on args', () => {
+    const controller = new Contoller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const tacos = controller.query(TacoList, { type: 'foo' }, state);
+    expect(tacos).toBeDefined();
+    expect(tacos?.[0]).toBeInstanceOf(Tacos);
+    expect(tacos).toMatchSnapshot();
+    const tacosBars = controller.query(TacoList, { type: 'bar' }, state);
+    expect(tacosBars).toBeDefined();
+    expect(tacosBars?.[0]).toBeInstanceOf(Tacos);
+    expect(tacosBars).not.toEqual(tacos);
+    // should maintain referential equality
+    expect(tacos).toBe(controller.query(TacoList, { type: 'foo' }, state));
+
+    const allTacos = controller.query(TacoList, state);
+    expect(allTacos).toBeDefined();
+    expect(allTacos).toHaveLength(2);
+    expect(allTacos).toMatchSnapshot();
+
+    // @ts-expect-error
+    () => controller.query(TacoList, 5, state);
+  });
+
+  it('query All', () => {
+    const controller = new Contoller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const AllTacos = new schema.All(Tacos);
+
+    const allTacos = controller.query(AllTacos, state);
+    expect(allTacos).toBeDefined();
+    expect(allTacos).toHaveLength(2);
+    expect(allTacos).toMatchSnapshot();
+    // should maintain referential equality
+    // TODO: (add infer cache) expect(allTacos).toBe(controller.query(TacoList, state));
+
+    // TODO: @ts-expect-error (we have a hack to make this not break other things now)
+    () => controller.query(AllTacos, 5, state);
+  });
+
+  it('Query+All based on args', () => {
+    const controller = new Contoller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const QueryTacos = new schema.Query(
+      new schema.All(Tacos),
+      (tacos, { type }: { type?: string } = {}) => {
+        if (!type) return tacos;
+        return tacos.filter(taco => taco.type === type);
+      },
+    );
+
+    const tacos = controller.query(QueryTacos, { type: 'foo' }, state);
+    expect(tacos).toBeDefined();
+    expect(tacos?.[0]).toBeInstanceOf(Tacos);
+    expect(tacos).toMatchSnapshot();
+    const tacosBars = controller.query(QueryTacos, { type: 'bar' }, state);
+    expect(tacosBars).toBeDefined();
+    expect(tacosBars?.[0]).toBeInstanceOf(Tacos);
+    expect(tacosBars).not.toEqual(tacos);
+    // should maintain referential equality
+    // TODO: (add infer cache) expect(tacos).toBe(controller.query(QueryTacos, { type: 'foo' }, state));
+
+    const allTacos = controller.query(QueryTacos, state);
+    expect(allTacos).toBeDefined();
+    expect(allTacos).toHaveLength(2);
+    expect(allTacos).toMatchSnapshot();
+
+    // @ts-expect-error
+    () => controller.query(QueryTacos, 5, state);
+  });
+
+  it('Query+Collection based on args', () => {
+    const controller = new Contoller();
+    const state = {
+      ...initialState,
+      entities,
+    };
+    const tacoCount = new schema.Query(TacoList, tacos => {
+      return tacos.length;
+    });
+
+    expect(controller.query(tacoCount, { type: 'foo' }, state)).toBe(1);
+    expect(controller.query(tacoCount, { type: 'bar' }, state)).toBe(1);
+    expect(controller.query(tacoCount, state)).toBe(2);
+  });
+
+  // TODO: test Union
+});

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/normal.ts

@@ -119,8 +119,8 @@ export interface EntityMap<T = any> {
   readonly [k: string]: EntityInterface<T>;
 }
 
-export type SchemaArgs<S extends Queryable> =
-  S extends EntityInterface<infer U> ? EntityFields<U>
+export type SchemaArgs<S extends Schema | undefined> =
+  S extends EntityInterface<infer U> ? [EntityFields<U>]
   : S extends (
     {
       infer(