quetch 0.9.2 → 0.10.0

package/doc/interfaces/CustomFetch.md

@@ -12,49 +12,24 @@
 
 ### CustomFetch
 
-▸ **CustomFetch**<`Q`\>(`query`): `Promise`<[`Result`](../README.md#result)<`T`, `Q`, {}, { readonly [K in string \| number \| symbol]: K extends keyof T ? T[K] : K extends never ? Object[K] extends FieldFunctionCustom<T\> ? ReturnType<Object[K]["value"]\> : Object[K]["operator"] extends "formatDate" ? FieldFunctionReturn[Object[K]["operator"]] : never : never }\>\>
+▸ **CustomFetch**<`Q`\>(`query`): `Promise`<[`Result`](../README.md#result)<`T`, `Q`\>\>
 
 #### Type parameters
 
 | Name | Type |
 | :------ | :------ |
-| `Q` | extends [`Query`](../README.md#query)<`T`, {}\> |
+| `Q` | extends [`Query`](../README.md#query)<`T`\> |
 
 #### Parameters
 
 | Name | Type |
 | :------ | :------ |
-| `query` | `Q` & { `customFields?`: `undefined`  } |
+| `query` | `Q` |
 
 #### Returns
 
-`Promise`<[`Result`](../README.md#result)<`T`, `Q`, {}, { readonly [K in string \| number \| symbol]: K extends keyof T ? T[K] : K extends never ? Object[K] extends FieldFunctionCustom<T\> ? ReturnType<Object[K]["value"]\> : Object[K]["operator"] extends "formatDate" ? FieldFunctionReturn[Object[K]["operator"]] : never : never }\>\>
+`Promise`<[`Result`](../README.md#result)<`T`, `Q`\>\>
 
 #### Defined in
 
-[lib/types/CustomFetch.ts:6](https://github.com/nevoland/quetch/blob/91f8b5b/lib/types/CustomFetch.ts#L6)
-
-### CustomFetch
-
-▸ **CustomFetch**<`Q`, `C`\>(`query`): `Promise`<[`Result`](../README.md#result)<`T`, `Q`, `C`, [`InjectCustomFields`](../README.md#injectcustomfields)<`T`, `C`\>\>\>
-
-#### Type parameters
-
-| Name | Type |
-| :------ | :------ |
-| `Q` | extends [`Query`](../README.md#query)<`T`, `C`\> |
-| `C` | extends [`CustomFieldMap`](../README.md#customfieldmap)<`T`\> |
-
-#### Parameters
-
-| Name | Type |
-| :------ | :------ |
-| `query` | `Q` & { `customFields`: `C`  } |
-
-#### Returns
-
-`Promise`<[`Result`](../README.md#result)<`T`, `Q`, `C`, [`InjectCustomFields`](../README.md#injectcustomfields)<`T`, `C`\>\>\>
-
-#### Defined in
-
-[lib/types/CustomFetch.ts:9](https://github.com/nevoland/quetch/blob/91f8b5b/lib/types/CustomFetch.ts#L9)
+[lib/types/CustomFetch.ts:5](https://github.com/nevoland/quetch/blob/c78a2c0/lib/types/CustomFetch.ts#L5)

package/lib/errors/RequestError.ts

@@ -1,4 +1,4 @@
-import type { QueryAny } from "../types";
+import type { Query } from "../types/Query";
 
 /**
  * Error to be thrown in case there is an issue with the query call. Only instances of this error will be caught by the `retry()` middleware.
@@ -7,7 +7,7 @@ export class RequestError extends Error {
   constructor(
     message: string,
     public status: number,
-    public query?: QueryAny,
+    public query?: Query<any>,
     public request?: Request,
     public response?: Response,
   ) {

package/lib/middlewares/aggregate.ts

@@ -1,7 +1,7 @@
 import { sleep } from "futurise";
 
 import { RequestError } from "../errors.js";
-import type { Handler, QueryAny } from "../types";
+import type { Handler, Query } from "../types";
 
 /**
  * Aggregates multiple incoming query calls into one query.
@@ -13,7 +13,12 @@ import type { Handler, QueryAny } from "../types";
  * @param options
  * @returns
  */
-export function aggregate<I extends QueryAny, O, In extends QueryAny, On>({
+export function aggregate<
+  I extends Query<any> & { type: any },
+  O,
+  In extends Query<any> & { type: any },
+  On,
+>({
   queryGroupId = ({ type, method = "get" }) => {
     if (method !== "get") {
       return undefined;
@@ -31,7 +36,7 @@ export function aggregate<I extends QueryAny, O, In extends QueryAny, On>({
   },
   mergeQuery = (query, _currentQuery) => query,
   delay = 200,
-  queryForGroup = (queryList, _): QueryAny => ({
+  queryForGroup = (queryList, _) => ({
     filter: {
       field: "id",
       operator: "include",
@@ -55,7 +60,7 @@ export function aggregate<I extends QueryAny, O, In extends QueryAny, On>({
   queryId?: (query: I) => string | undefined;
   mergeQuery?: (query: I, currentQuery: I) => I;
   delay?: number;
-  queryForGroup: (queryList: I[], group: string) => QueryAny;
+  queryForGroup: (queryList: I[], group: string) => Query<any> & { type: any };
   resultForQuery: (resultList: O[], query: I) => O | never;
 }): Handler<I, O, In, On> {
   const queryGroupMap = new Map<

package/lib/middlewares/cache.ts

@@ -1,11 +1,28 @@
-import type { Handler, QueryAny, Store } from "../types";
+import type { Handler, Query, Store } from "../types";
 
-type CachedItem<I extends QueryAny> = {
+type CachedItem<I extends Query<any>> = {
   query: I;
   value: any;
 };
 
-type CacheOptions<I extends QueryAny> = {
+export function cache<
+  I extends Query<any> & { type: any },
+  O,
+  In extends Query<any>,
+  On,
+>({
+  itemId = ({ context = {}, method = "read", type }: I) => {
+    if (method === "read" && context.id) {
+      return `${String(type)}/${context.id}`;
+    }
+    return undefined;
+  },
+  store,
+  invalidatesItem,
+  extendCachedQuery,
+  mergeQuery,
+  mergeItem,
+}: {
   /**
    * Unique identifier for the item to cache.
    * Returns `undefined` if the item should not be cached.
@@ -34,21 +51,7 @@ type CacheOptions<I extends QueryAny> = {
    * Only called when `extendCachedQuery` returns a query.
    */
   mergeItem: (value: any, cachedValue: any, query: I, cachedQuery: I) => any;
-};
-
-export function cache<I extends QueryAny, O, In extends QueryAny, On>({
-  itemId = ({ context = {}, method = "read", type }: I) => {
-    if (method === "read" && context.id) {
-      return `${String(type)}/${context.id}`;
-    }
-    return undefined;
-  },
-  store,
-  invalidatesItem,
-  extendCachedQuery,
-  mergeQuery,
-  mergeItem,
-}: CacheOptions<I>): Handler<I, O, In, On> {
+}): Handler<I, O, In, On> {
   /*
   Caches the result of a query if `serialize` returns a non-empty string key. The `engine` should follow the `Map` API. Elements are kept in the cache until the `duration` in milliseconds expires.
   Note that a `duration` set to `Infinity` indefinitely keeps items in the cache.

package/lib/middlewares/fetchLocal.ts

@@ -1,5 +1,5 @@
 import { queryItemList } from "../tools/queryItemList.js";
-import type { CustomFieldMap, Handler, Query } from "../types";
+import type { Handler, Query } from "../types";
 
 /**
  * Performs the fetch query on local data.
@@ -7,20 +7,7 @@ import type { CustomFieldMap, Handler, Query } from "../types";
  * @returns Promise that resolves to the response.
  */
 export function fetchLocal<T extends object>(): Handler<
-  Query<T, undefined> & { type: T[]; customFields: never },
-  any,
-  never,
-  never
->;
-export function fetchLocal<
-  T extends object,
-  C extends CustomFieldMap<T>,
->(): Handler<Query<T, C> & { type: T[]; customFields: C }, any, never, never>;
-export function fetchLocal<
-  T extends object,
-  C extends CustomFieldMap<T>,
->(): Handler<
-  Query<T, C> & { type: T[]; customFields: C | never },
+  Query<T> & { type: T[] },
   any,
   never,
   never

package/lib/tools/defineCheckQuery.ts

@@ -1,4 +1,4 @@
-import type { CustomFieldMap, Query } from "../types";
+import type { Query } from "../types";
 
 /**
  * Returns a function that checks queries. This is useful to prevent the query to have its type being narrowed if declared outside of a custom fetcher function argument.
@@ -6,23 +6,19 @@ import type { CustomFieldMap, Query } from "../types";
  * @returns Function that checks queries.
  */
 export function defineCheckQuery<M extends Record<string, object>>() {
-  function checkQuery<
-    T extends object,
-    C extends CustomFieldMap<T>,
-    const Q extends Query<T, C>,
-  >(query: Q & { type: T[]; customFields?: C }): typeof query;
+  function checkQuery<T extends object, const Q extends Query<T>>(
+    query: Q & { type: T[] },
+  ): typeof query;
   function checkQuery<
     K extends keyof M,
     T extends M[K],
-    C extends CustomFieldMap<T>,
-    const Q extends Query<T, C>,
-  >(query: Q & { type: K; customFields?: C }): typeof query;
+    const Q extends Query<T>,
+  >(query: Q & { type: K }): typeof query;
   function checkQuery<
     K extends keyof M,
     T extends M[K] | object,
-    C extends CustomFieldMap<T>,
-    const Q extends Query<T, C>,
-  >(query: Q & { type: K | T[]; customFields?: C }): typeof query {
+    const Q extends Query<T>,
+  >(query: Q & { type: K | T[] }): typeof query {
     return query;
   }
   return checkQuery;

package/lib/tools/defineCustomFetch.ts

@@ -1,52 +1,30 @@
-import type { CustomFieldMap, Handler, Key, Query, Result } from "../types";
+import type { Handler, Key, Query, Result } from "../types";
 
 import { cork } from "./cork.js";
 
 /**
+ * Returns a custom fetch function that handles a `query`
  *
- *
- * @param handler
- * @returns
+ * @param handler The query handler.
+ * @returns A custom fetch function.
  */
 export function defineCustomFetch<M extends Record<string, object>>(
-  handler: Handler<
-    Query<any, any> & { type: Key | any[]; customFields?: CustomFieldMap<any> },
-    any,
-    never,
-    never
-  >,
+  handler: Handler<Query<any> & { type: Key | any[] }, any, never, never>,
 ) {
   async function customFetch<
     K extends keyof M,
     T extends M[K],
-    const Q extends Query<T, undefined>,
-  >(
-    query: Q & { type: K; customFields?: never },
-  ): Promise<Result<T, Q, undefined>>;
-  async function customFetch<
-    K extends keyof M,
-    T extends M[K],
-    const Q extends Query<T, C>,
-    const C extends CustomFieldMap<T>,
-  >(query: Q & { type: K; customFields: C }): Promise<Result<T, Q, C>>;
-  async function customFetch<
-    T extends object,
-    const Q extends Query<T, undefined>,
-  >(
+    const Q extends Query<T>,
+  >(query: Q & { type: K }): Promise<Result<T, Q>>;
+  async function customFetch<T extends object, const Q extends Query<T>>(
     type: T[],
-    query: Q & { customFields?: never },
-  ): Promise<Result<T, Q, undefined>>;
-  async function customFetch<
-    T extends object,
-    const Q extends Query<T, C>,
-    const C extends CustomFieldMap<T>,
-  >(query: Q & { type: T[]; customFields: C }): Promise<Result<T, Q, C>>;
+    query: Q,
+  ): Promise<Result<T, Q>>;
   async function customFetch<
     K extends keyof M,
     T extends M[K] | object,
-    const Q extends Query<T, C>,
-    const C extends CustomFieldMap<T>,
-  >(query: Q & { type: T[] | K; customFields?: C }): Promise<Result<T, Q, C>> {
+    const Q extends Query<T>,
+  >(query: Q & { type: T[] | K }): Promise<Result<T, Q>> {
     return await handler(query as any, cork);
   }
   return customFetch;

package/lib/tools/defineGenericFetch.ts

@@ -1,30 +1,24 @@
-import type { CustomFieldMap, Handler, Key, Query, Result } from "../types";
+import type { Handler, Key, Query, Result } from "../types";
 
 import { cork } from "./cork.js";
 
+/**
+ * Returns a generic fetch function that has to be called like this:
+ * ```ts
+ * genericFetch<T>()(query)
+ * ```
+ *
+ * @param handler The query handler.
+ * @returns A curried generic fetch function.
+ */
 export function defineGenericFetch<K extends string>(
-  handler: Handler<
-    Query<any, any> & { type: Key | any[]; customFields?: CustomFieldMap<any> },
-    any,
-    never,
-    never
-  >,
+  handler: Handler<Query<any> & { type: Key | any[] }, any, never, never>,
 ) {
   // FIXME: Until https://github.com/microsoft/TypeScript/issues/26242 gets resolved, the fetcher needs to be curried
   function genericFetch<T extends object>() {
-    async function customFetch<const Q extends Query<T, undefined>>(
-      query: Q & { type: K | T[]; customFields?: never },
-    ): Promise<Result<T, Q, undefined>>;
-    async function customFetch<
-      const Q extends Query<T, C>,
-      const C extends CustomFieldMap<T>,
-    >(query: Q & { type: K | T[]; customFields: C }): Promise<Result<T, Q, C>>;
-    async function customFetch<
-      const Q extends Query<T, C>,
-      const C extends CustomFieldMap<T>,
-    >(
-      query: Q & { type: K | T[]; customFields?: C },
-    ): Promise<Result<T, Q, C>> {
+    async function customFetch<const Q extends Query<T>>(
+      query: Q & { type: K | T[] },
+    ): Promise<Result<T, Q>> {
       return await handler(query as any, cork);
     }
     return customFetch;

package/lib/tools/filterItem.ts

@@ -1,6 +1,6 @@
 import { SymbolCache } from "../constants/SymbolCache.js";
 import type { Any, Filter, FilterKeys } from "../types";
-import type { QuerySettings } from "../types/QuerySettings";
+import type { QuerySettings } from "../types/QuerySettings.js";
 
 import { filterChildren } from "./filterChildren.js";
 

package/lib/tools/queryItemList.ts

@@ -3,11 +3,9 @@ import type {
   AggregateFunction,
   AggregateFunctionOperator,
   Context,
-  CustomFieldMap,
   Filter,
   Order,
   Query,
-  QueryAny,
   Result,
 } from "../types.js";
 
@@ -40,19 +38,9 @@ function normalizeAggregator<T extends object>(
   return aggregator.operator;
 }
 
-function queryItemList<T extends object, const Q extends Query<T, undefined>>(
-  query: Q & { type: T[]; customFields?: never },
-): Result<T, Q, undefined>;
-function queryItemList<
-  T extends object,
-  const Q extends Query<T, C>,
-  const C extends CustomFieldMap<T>,
->(query: Q & { type: T[]; customFields: C }): Result<T, Q, C>;
-function queryItemList<
-  T extends object,
-  const Q extends Query<T, C>,
-  const C extends CustomFieldMap<T>,
->(query: Q & { type: T[]; customFields?: C }): Result<T, Q, C> {
+function queryItemList<T extends object, const Q extends Query<T>>(
+  query: Q & { type: T[] },
+): Result<T, Q> {
   const data = query.type as T[];
   switch (query.method) {
     case "read":
@@ -80,7 +68,7 @@ function queryItemList<
         if (offset !== 0 || limit !== Infinity) {
           result = result.slice(offset, offset + limit);
         }
-        return result as Result<T, Q, C>;
+        return result as Result<T, Q>;
       }
       const normalizedFilter = mergeContextAndFilter(
         context,
@@ -90,16 +78,16 @@ function queryItemList<
         filterItem(normalizedFilter, item, query.settings),
       );
       if (result === undefined) {
-        throw new RequestError("Not found", 404, query as QueryAny);
+        throw new RequestError("Not found", 404, query as Query<any>);
       }
-      return result as Result<T, Q, C>;
+      return result as Result<T, Q>;
     }
     case "aggregate": {
       const { context, filter, aggregator } = query;
       switch (normalizeAggregator(aggregator)) {
         case "length": {
           if (filter === undefined && context === undefined) {
-            return data.length as Result<T, Q, C>;
+            return data.length as Result<T, Q>;
           }
           const normalizedFilter = mergeContextAndFilter(
             context,
@@ -110,7 +98,7 @@ function queryItemList<
               return result + 1;
             }
             return result;
-          }, 0 as number) as Result<T, Q, C>;
+          }, 0 as number) as Result<T, Q>;
         }
         default: {
           throw new Error("Not implemented");

package/lib/types/CustomFetch.ts

@@ -1,12 +1,6 @@
-import type { CustomFieldMap } from "./CustomFieldMap";
 import type { Query } from "./Query";
 import type { Result } from "./Result";
 
 export interface CustomFetch<T extends object> {
-  <Q extends Query<T, {}>>(
-    query: Q & { customFields?: never },
-  ): Promise<Result<T, Q, {}>>;
-  <Q extends Query<T, C>, C extends CustomFieldMap<T>>(
-    query: Q & { customFields: C },
-  ): Promise<Result<T, Q, C>>;
+  <Q extends Query<T>>(query: Q): Promise<Result<T, Q>>;
 }

package/lib/types/Group.ts

@@ -1,5 +1,3 @@
-import type { CustomFieldAggregateMap } from "./CustomFieldAggregateMap";
-
 /**
  * Specifies how items should be grouped.
  */
@@ -7,5 +5,4 @@ export type Group<T extends object> =
   | keyof T
   | {
       field: keyof T;
-      customFields?: CustomFieldAggregateMap<T>;
     };

package/lib/types/Parameters.ts

@@ -0,0 +1 @@
+export type Parameters = Record<string, string | string[] | number | number[]>;

package/lib/types/Query.ts

@@ -1,6 +1,3 @@
-import type { Context } from "./Context";
-import type { CustomFieldMap } from "./CustomFieldMap";
-import type { InjectCustomFields } from "./InjectCustomFields";
 import type { QueryAggregate } from "./QueryAggregate";
 import type { QueryCreate } from "./QueryCreate";
 import type { QueryCreateMultiple } from "./QueryCreateMultiple";
@@ -8,11 +5,18 @@ import type { QueryDelete } from "./QueryDelete";
 import type { QueryDeleteMultiple } from "./QueryDeleteMultiple";
 import type { QueryRead } from "./QueryRead";
 import type { QueryReadMultiple } from "./QueryReadMultiple";
-import type { QuerySettings } from "./QuerySettings";
 import type { QueryUpdate } from "./QueryUpdate";
 import type { QueryUpdateMultiple } from "./QueryUpdateMultiple";
 
-type QueryBase<T extends object> =
+/**
+ * Query that fetches or mutates an entity.
+ */
+export type Query<
+  /**
+   * Type of the object item to be queried.
+   */
+  T extends object,
+> =
   | QueryRead<T>
   | QueryReadMultiple<T>
   | QueryCreate<T>
@@ -22,41 +26,3 @@ type QueryBase<T extends object> =
   | QueryDelete<T>
   | QueryDeleteMultiple<T>
   | QueryAggregate<T>;
-
-/**
- * Query that fetches or mutates an entity.
- */
-export type Query<
-  /**
-   * Type.
-   */
-  T extends object,
-  /**
-   * Custom fields.
-   */
-  C extends CustomFieldMap<T> | undefined,
-  /**
-   * Methods.
-   */
-  M extends QueryBase<never>["method"] = QueryBase<never>["method"],
-  /**
-   * Multiple.
-   */
-  L extends boolean | undefined = boolean,
-> = Extract<
-  QueryBase<InjectCustomFields<T, C>>,
-  { method?: M; multiple?: L }
-> & {
-  /**
-   * Common item properties to use for identifying the item.
-   */
-  context?: Context<T>;
-  /**
-   * Query parameters.
-   */
-  parameters?: Record<string, string | string[] | number | number[]>;
-  /**
-   * Query settings.
-   */
-  settings?: QuerySettings<T>;
-};

package/lib/types/QueryAggregate.ts

@@ -1,11 +1,26 @@
 import type { AggregateFunction } from "./AggregateFunction";
+import type { Context } from "./Context";
 import type { Filter } from "./Filter";
+import type { Parameters } from "./Parameters";
+import type { QuerySettings } from "./QuerySettings";
 
 /**
  * Query for computing an aggregated value.
  */
 export type QueryAggregate<T extends object> = {
   method: "aggregate";
+  /**
+   * Common item properties to use for identifying the item.
+   */
+  context?: Context<T>;
   aggregator: AggregateFunction<T>;
   filter?: Filter<T>;
+  /**
+   * Query parameters.
+   */
+  parameters?: Parameters;
+  /**
+   * Query settings.
+   */
+  settings?: QuerySettings<T>;
 };

package/lib/types/QueryCreate.ts

@@ -1,8 +1,27 @@
+import type { Context } from "./Context";
+import type { Parameters } from "./Parameters";
+import type { QuerySettings } from "./QuerySettings";
+
 /**
  * Query for creating an item.
  */
 export type QueryCreate<T extends object> = {
   method: "create";
   multiple?: false;
+  /**
+   * Common item properties to use for identifying the context in which to create the item.
+   */
+  context?: Context<T>;
+  /**
+   * Value properties of the item to create.
+   */
   value: Partial<T>;
+  /**
+   * Query parameters.
+   */
+  parameters?: Parameters;
+  /**
+   * Query settings.
+   */
+  settings?: QuerySettings<T>;
 };

package/lib/types/QueryCreateMultiple.ts

@@ -1,8 +1,24 @@
+import type { Context } from "./Context";
+import type { Parameters } from "./Parameters";
+import type { QuerySettings } from "./QuerySettings";
+
 /**
  * Query for creating multiple items.
  */
 export type QueryCreateMultiple<T extends object> = {
   method: "create";
   multiple: true;
+  /**
+   * Common item properties to use for identifying the context in which to create the items.
+   */
+  context?: Context<T>;
   value: Partial<T>[];
+  /**
+   * Query parameters.
+   */
+  parameters?: Parameters;
+  /**
+   * Query settings.
+   */
+  settings?: QuerySettings<T>;
 };

package/lib/types/QueryDelete.ts

@@ -1,5 +1,7 @@
-import type { CustomFieldMap } from "./CustomFieldMap";
+import type { Context } from "./Context";
 import type { Filter } from "./Filter";
+import type { Parameters } from "./Parameters";
+import type { QuerySettings } from "./QuerySettings";
 
 /**
  * Query for deleting an item.
@@ -7,6 +9,17 @@ import type { Filter } from "./Filter";
 export type QueryDelete<T extends object> = {
   method: "delete";
   multiple?: false;
+  /**
+   * Common item properties to use for identifying the context in which to delete the item.
+   */
+  context?: Context<T>;
   filter?: Filter<T>;
-  customFields?: CustomFieldMap<T>;
+  /**
+   * Query parameters.
+   */
+  parameters?: Parameters;
+  /**
+   * Query settings.
+   */
+  settings?: QuerySettings<T>;
 };

package/lib/types/QueryDeleteMultiple.ts

@@ -1,5 +1,7 @@
-import type { CustomFieldMap } from "./CustomFieldMap";
+import type { Context } from "./Context";
 import type { Filter } from "./Filter";
+import type { Parameters } from "./Parameters";
+import type { QuerySettings } from "./QuerySettings";
 
 /**
  * Query for deleting multiple items.
@@ -7,6 +9,17 @@ import type { Filter } from "./Filter";
 export type QueryDeleteMultiple<T extends object> = {
   method: "delete";
   multiple: true;
+  /**
+   * Common item properties to use for identifying the context in which to delete the item.
+   */
+  context?: Context<T>;
   filter?: Filter<T>;
-  customFields?: CustomFieldMap<T>;
+  /**
+   * Query parameters.
+   */
+  parameters?: Parameters;
+  /**
+   * Query settings.
+   */
+  settings?: QuerySettings<T>;
 };

package/lib/types/QueryMethod.ts

@@ -3,4 +3,4 @@ import type { Query } from "./Query";
 /**
  * Available query methods.
  */
-export type QueryMethod = Exclude<Query<never, never>["method"], undefined>;
+export type QueryMethod = Exclude<Query<never>["method"], undefined>;