quetch 0.18.2 → 0.19.0

package/dist/types/QueryAggregate.d.ts

@@ -7,7 +7,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for computing an aggregated value.
  */
-export type QueryAggregate<T extends object> = {
+export type QueryAggregate<T> = {
     method: "aggregate";
     /**
      * Common item properties to use for identifying the item.

package/dist/types/QueryCreate.d.ts

@@ -4,7 +4,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for creating an item.
  */
-export type QueryCreate<T extends object> = {
+export type QueryCreate<T> = {
     method: "create";
     multiple?: false;
     /**

package/dist/types/QueryCreateMultiple.d.ts

@@ -4,7 +4,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for creating multiple items.
  */
-export type QueryCreateMultiple<T extends object> = {
+export type QueryCreateMultiple<T> = {
     method: "create";
     multiple: true;
     /**

package/dist/types/QueryDelete.d.ts

@@ -5,7 +5,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for deleting an item.
  */
-export type QueryDelete<T extends object> = {
+export type QueryDelete<T> = {
     method: "delete";
     multiple?: false;
     /**

package/dist/types/QueryDeleteMultiple.d.ts

@@ -5,7 +5,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for deleting multiple items.
  */
-export type QueryDeleteMultiple<T extends object> = {
+export type QueryDeleteMultiple<T> = {
     method: "delete";
     multiple: true;
     /**

package/dist/types/QueryRead.d.ts

@@ -6,7 +6,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for reading a single item.
  */
-export type QueryRead<T extends object> = {
+export type QueryRead<T> = {
     method?: "read";
     multiple?: false;
     /**

package/dist/types/QueryReadMultiple.d.ts

@@ -7,7 +7,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for getting a list of items.
  */
-export type QueryReadMultiple<T extends object> = {
+export type QueryReadMultiple<T> = {
     method?: "read";
     multiple: true;
     /**

package/dist/types/QuerySettings.d.ts

@@ -4,7 +4,7 @@ import type { FilterChildren } from "./FilterChildren";
 /**
  * Settings to use when doing a query.
  */
-export type QuerySettings<T extends object> = {
+export type QuerySettings<T> = {
     /**
      * String used to separate the path nodes of an item.
      */

package/dist/types/QueryUpdate.d.ts

@@ -5,7 +5,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for updating an item.
  */
-export type QueryUpdate<T extends object> = {
+export type QueryUpdate<T> = {
     method: "update";
     multiple?: false;
     /**

package/dist/types/QueryUpdateMultiple.d.ts

@@ -6,7 +6,7 @@ import type { QuerySettings } from "./QuerySettings";
 /**
  * Query for updating multiple items.
  */
-export type QueryUpdateMultiple<T extends object> = {
+export type QueryUpdateMultiple<T> = {
     method: "update";
     multiple: true;
     /**

package/dist/types/Result.d.ts

@@ -3,21 +3,21 @@ import type { Query } from "./Query";
 /**
  * Picks fields `F` from object `T`.
  */
-export type PickFields<T extends object | undefined, F extends string | number | symbol> = [F] extends [keyof T] ? {
+export type PickFields<T, F extends string | number | symbol> = [F] extends [
+    keyof T
+] ? {
     readonly [K in F]: T[K];
 } : {
     readonly [K in keyof T]: T[K];
 };
-export type ResultRead<T extends object, Q extends Query<T>> = [Q] extends [
+export type ResultRead<T, Q extends Query<T>> = [Q] extends [
     {
         fields: (keyof T)[];
     }
 ] ? PickFields<T, Item<Q["fields"]>> : T;
-export type Result<T extends object, Q extends Query<T>> = [Q] extends [
-    {
-        method: "read";
-    }
-] ? [Q] extends [{
+export type Result<T, Q extends Query<T>> = [Q] extends [{
+    method: "read";
+}] ? [Q] extends [{
     multiple: true;
 }] ? readonly ResultRead<T, Q>[] : ResultRead<T, Q> : [Q] extends [{
     method: "aggregate";

package/dist/types/Value.d.ts

@@ -2,7 +2,7 @@ import type { FieldFiltered } from "./FieldFiltered";
 /**
  * Actual `value` or `valueField` leading to the value.
  */
-export type Value<T extends object, V> = {
+export type Value<T, V> = {
     /**
      * Value to use.
      */

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 export type { AggregateFunction } from "./types/AggregateFunction";
 export type { AggregateFunctionOperator } from "./types/AggregateFunctionOperator";
-export type { Any } from "./types/Any";
+export type { CombineUnion } from "./types/CombineUnion";
 export type { Context } from "./types/Context";
 export type { CustomFetch } from "./types/CustomFetch";
 export type { CustomFieldAggregateMap } from "./types/CustomFieldAggregateMap";
@@ -34,14 +34,14 @@ export type { Item } from "./types/Item";
 export type { Join } from "./types/Join";
 export type { Key } from "./types/Key";
 export type { KeyFiltered } from "./types/KeyFiltered";
+export type { KeyFromUnion } from "./types/KeyFromUnion";
 export type { Locale } from "./types/Locale";
-export type { Mutable } from "./types/Mutable";
 export type { NextHandler } from "./types/NextHandler";
-export type { Normalized } from "./types/Normalized";
 export type { Order } from "./types/Order";
 export type { Parameters } from "./types/Parameters";
 export type { Path } from "./types/Path";
 export type { PathFiltered } from "./types/PathFiltered";
+export type { Primitive } from "./types/Primitive";
 export type { Query } from "./types/Query";
 export type { QueryAggregate } from "./types/QueryAggregate";
 export type { QueryCreate } from "./types/QueryCreate";

package/lib/constants/SymbolSelf.ts

@@ -0,0 +1 @@
+export const SymbolSelf = Symbol("self");

package/lib/constants.ts

@@ -1,2 +1,3 @@
 // File automatically generated by `vite-plugin-module-list`
 export { SymbolCache } from "./constants/SymbolCache.js";
+export { SymbolSelf } from "./constants/SymbolSelf.js";

package/lib/middlewares/fetchLocal.ts

@@ -6,7 +6,7 @@ import type { Handler, Query } from "../types";
  *
  * @returns Promise that resolves to the response.
  */
-export function fetchLocal<T extends object>(): Handler<
+export function fetchLocal<T>(): Handler<
   Query<T> & { type: T[] },
   any,
   never,

package/lib/tools/defineCheckQuery.ts

@@ -6,7 +6,7 @@ import type { Query } from "../types";
  * @returns Function that checks queries.
  */
 export function defineCheckQuery<M extends Record<string, object>>() {
-  function checkQuery<T extends object, const Q extends Query<T>>(
+  function checkQuery<T, const Q extends Query<T>>(
     query: Q & { type: T[] },
   ): typeof query;
   function checkQuery<

package/lib/tools/defineCustomFetch.ts

@@ -16,7 +16,7 @@ export function defineCustomFetch<M extends Record<string, object>>(
     T extends M[K],
     const Q extends Query<T>,
   >(query: Q & { type: K }): Promise<Result<T, Q>>;
-  async function customFetch<T extends object, const Q extends Query<T>>(
+  async function customFetch<T, const Q extends Query<T>>(
     type: T[],
     query: Q,
   ): Promise<Result<T, Q>>;

package/lib/tools/defineGenericFetch.ts

@@ -15,7 +15,7 @@ export function defineGenericFetch<K extends string>(
   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>() {
+  function genericFetch<T>() {
     async function customFetch<const Q extends Query<T>>(
       query: Q & { type: K | T[] },
     ): Promise<Result<T, Q>> {

package/lib/tools/fieldListFromFilter.ts

@@ -8,7 +8,7 @@ import type { Field, Filter } from "../types";
  * @param filter The filter to extract the fields from.
  * @returns A list of fields.
  */
-export function fieldListFromFilter<T extends object>(
+export function fieldListFromFilter<T>(
   filter?: Filter<T>,
 ): readonly Field<T>[] {
   if (filter === undefined) {

package/lib/tools/filterChildren.ts

@@ -2,7 +2,7 @@ import type { FieldFiltered, Filter } from "../types.ts";
 
 import { escapeRegex } from "./escapeRegex.js";
 
-export function filterChildren<T extends object>(
+export function filterChildren<T>(
   parentPath: string,
   pathFieldKey: FieldFiltered<T, string>,
   deep = false,

package/lib/tools/filterFromContext.test.ts

@@ -23,6 +23,36 @@ test("returns filter from context", () => {
       },
     ],
   });
+  expect(filterFromContext({ a: { b: undefined } })).toEqual({
+    operator: "all",
+    value: [
+      {
+        field: ["a", "b"],
+        operator: "equal",
+        value: undefined,
+      },
+    ],
+  });
+  expect(filterFromContext({ a: { b: null } })).toEqual({
+    operator: "all",
+    value: [
+      {
+        field: ["a", "b"],
+        operator: "equal",
+        value: null,
+      },
+    ],
+  });
+  expect(filterFromContext({ a: null })).toEqual({
+    operator: "all",
+    value: [
+      {
+        field: "a",
+        operator: "equal",
+        value: null,
+      },
+    ],
+  });
   expect(filterFromContext({ a: { b: 1 }, c: 2 })).toEqual({
     operator: "all",
     value: [

package/lib/tools/filterFromContext.ts

@@ -4,16 +4,14 @@ import type { Context, Filter } from "../types";
 
 const { entries } = Object;
 
-export function filterFromContext<T extends object>(
-  context: Context<T>,
-): Filter<T> {
+export function filterFromContext<T>(context: Context<T>): Filter<T> {
   return {
     operator: "all",
     value: criteria(context),
   };
 }
 
-function criteria<T extends object>(
+function criteria<T>(
   context: object,
   path: readonly string[] = EMPTY_ARRAY,
 ): readonly Filter<T>[] {
@@ -32,8 +30,18 @@ function criteria<T extends object>(
             value,
           } as Filter<T>,
         ];
-      case "object":
+      case "object": {
+        if (value == null) {
+          return [
+            {
+              field: path.length === 0 ? field : [...path, field],
+              operator: "equal",
+              value,
+            } as Filter<T>,
+          ];
+        }
         return criteria(value, [...path, field]);
+      }
       default:
         return EMPTY_ARRAY;
       // Ignore

package/lib/tools/get.test.ts

@@ -14,6 +14,7 @@ test("gets properties", () => {
   expect(result2).toBe(value.a.d.e[2].f);
 
   const result3 = get(value, ["a"]);
+  expect(result3.b).toBe(value.a.b);
   expect(result3).toBe(value.a);
 
   const result4 = get(value, "a");

package/lib/tools/get.ts

@@ -1,4 +1,4 @@
-import type { Field, Get } from "../types";
+import type { Get, Path } from "../types";
 
 /**
  * Gets the property value of the given `value` at the specified `path` (an array of object property names or array indexes).
@@ -10,7 +10,10 @@ import type { Field, Get } from "../types";
  * @param path The path leading to the property value or a property name or `undefined`.
  * @returns The property value found at the given path, or `undefined` if it cannot be found.
  */
-export function get<T, P extends Field<T>>(value: T, path?: P): Get<T, P> {
+export function get<const T, const P extends Path<T> | keyof T>(
+  value: T,
+  path?: P,
+): Get<T, P> {
   if (path === undefined) {
     return value as any;
   }
@@ -20,19 +23,21 @@ export function get<T, P extends Field<T>>(value: T, path?: P): Get<T, P> {
     case "symbol":
       return (value as any)?.[path];
     default: {
-      switch (path.length) {
+      switch (path.length as number) {
+        case 0:
+          return value as any;
         case 1:
           return (value as any)?.[path[0] as any];
         case 2:
-          return (value as any)?.[path[0] as any]?.[path[1] as any];
+          return (value as any)?.[path[0] as any]?.[(path as any)[1] as any];
         case 3:
-          return (value as any)?.[path[0] as any]?.[path[1] as any]?.[
-            path[2] as any
+          return (value as any)?.[path[0] as any]?.[(path as any)[1] as any]?.[
+            (path as any)[2] as any
           ];
         case 4:
-          return (value as any)?.[path[0] as any]?.[path[1] as any]?.[
-            path[2] as any
-          ]?.[path[3] as any];
+          return (value as any)?.[path[0] as any]?.[(path as any)[1] as any]?.[
+            (path as any)[2] as any
+          ]?.[(path as any)[3] as any];
         default:
           return path.reduce(
             (value, key) => (value as any)?.[key],

package/lib/tools/isFilterGroup.ts

@@ -6,7 +6,7 @@ import type { Filter, FilterGroup } from "../types";
  * @param value The filter to test.
  * @returns Whether the provided filter is a group filter or not.
  */
-export function isFilterGroup<T extends object>(
+export function isFilterGroup<T>(
   value: Filter<T> | undefined,
 ): value is FilterGroup<T> {
   switch (value?.operator) {

package/lib/tools/normalizeOrder.ts

@@ -8,9 +8,7 @@ const isArray = Array.isArray as (value: any) => value is readonly any[];
  * @param order The string or order object.
  * @returns The normalized order object.
  */
-export function normalizeOrder<T extends object>(
-  order: Order<T>,
-): {
+export function normalizeOrder<T>(order: Order<T>): {
   field: Field<T>;
   descending?: boolean | undefined;
 } {

package/lib/tools/queryItemList.test.ts

@@ -5,7 +5,7 @@ import { queryItemList } from "./queryItemList.js";
 test("queries a single item", () => {
   expect(
     queryItemList({
-      type: [{ a: 1 }, { a: 2 }, { a: 3 }] as { a: number }[],
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
     }),
   ).toEqual({ a: 1 });
   expect(() =>
@@ -13,7 +13,7 @@ test("queries a single item", () => {
       context: {
         a: 4,
       },
-      type: [{ a: 1 }, { a: 2 }, { a: 3 }] as { a: number }[],
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }] as readonly { a: number }[],
     }),
   ).toThrow("Not found");
   expect(

package/lib/tools/queryItemList.ts

@@ -11,7 +11,7 @@ import { filterFromContext } from "./filterFromContext.js";
 import { sortItemList } from "./sortItemList.js";
 import { testFilter } from "./testFilter.js";
 
-function mergeContextAndFilter<T extends object>(
+function mergeContextAndFilter<T>(
   context?: Context<T>,
   filter?: Filter<T>,
 ): Filter<T> | undefined {
@@ -30,7 +30,7 @@ function mergeContextAndFilter<T extends object>(
   };
 }
 
-function normalizeAggregator<T extends object>(
+function normalizeAggregator<T>(
   aggregator: AggregateFunction<T>,
 ): Exclude<AggregateFunction<T>, string> {
   if (typeof aggregator === "string") {
@@ -45,7 +45,7 @@ function normalizeAggregator<T extends object>(
  * @param query The query to perform.
  * @returns The result of the query.
  */
-export function queryItemList<T extends object, const Q extends Query<T>>(
+export function queryItemList<T, const Q extends Query<T>>(
   query: Q & { type: readonly T[] },
 ): Result<T, Q> {
   const data = query.type;

package/lib/tools/reverseOrder.ts

@@ -8,9 +8,7 @@ import { normalizeOrder } from "./normalizeOrder.js";
  * @param order The order to reverse.
  * @returns The reversed order.
  */
-export function reverseOrder<T extends object>(
-  order: Order<T>,
-): {
+export function reverseOrder<T>(order: Order<T>): {
   field: Field<T>;
   descending?: boolean | undefined;
 } {

package/lib/tools/sortItemList.ts

@@ -10,7 +10,7 @@ import { normalizeOrder } from "./normalizeOrder.js";
  * @param value The array to sort.
  * @returns A new sorted array.
  */
-export function sortItemList<T extends object>(
+export function sortItemList<T>(
   orderList: readonly Order<T>[] | undefined,
   value: readonly T[],
 ) {
@@ -21,8 +21,8 @@ export function sortItemList<T extends object>(
   return [...value].sort((a, b) => {
     for (let index = 0; index < normalizedOrder.length; index++) {
       const { field, descending } = normalizedOrder[index]!;
-      const valueA = get(a, field);
-      const valueB = get(b, field);
+      const valueA = get(a, field as any);
+      const valueB = get(b, field as any);
       if (valueA === valueB) {
         continue;
       }

package/lib/tools/testFilter.test.ts

@@ -290,7 +290,7 @@ test("tests filter with children predicates", () => {
       },
     ),
   ).toBe(true);
-  const filterChildren: FilterChildren<any> = {
+  const filterChildren: FilterChildren<{ path: string }> = {
     operator: "children",
     value: "a",
   };

package/lib/tools/testFilter.ts

@@ -1,16 +1,13 @@
 import { SymbolCache } from "../constants/SymbolCache.js";
 import type { QuerySettings } from "../types/QuerySettings.js";
-import type { Any, FieldFiltered, Filter, FilterString } from "../types.js";
+import type { FieldFiltered, Filter, FilterString } from "../types.js";
 
 import { filterChildren } from "./filterChildren.js";
 import { get } from "./get.js";
 
 const { isArray } = Array;
 
-function valueFromFilter<T extends object, F extends Filter<T>>(
-  value: T,
-  filter: F,
-): F extends { value: infer V } ? V : never {
+function valueFromFilter<T>(value: T, filter: Filter<T>): any {
   if ("valueField" in filter) {
     filter.valueField;
     return get<T, any>(value, filter.valueField) as any;
@@ -26,7 +23,7 @@ function valueFromFilter<T extends object, F extends Filter<T>>(
  * @param settings Optional query settings.
  * @returns `true` if the `value` matches the `filter` and `false` otherwise.
  */
-export function testFilter<T extends object>(
+export function testFilter<T>(
   filter: Filter<T> | undefined,
   value: T | undefined,
   settings?: QuerySettings<T>,
@@ -53,12 +50,12 @@ export function testFilter<T extends object>(
       return filter.value.every((filter) => !testFilter(filter, value));
     }
     case "exist":
-      return get(value, filter.field) !== undefined;
+      return get(value, filter.field as any) !== undefined;
     case "equal": {
-      const rightValue = valueFromFilter(value, filter);
+      const rightValue = valueFromFilter(value, filter as Filter<any>);
       if (isArray(rightValue)) {
         filter.field;
-        const leftValue = get<T, any>(value, filter.field) as Any[] | undefined;
+        const leftValue = get<T, any>(value, filter.field);
         if (!isArray(leftValue)) {
           return false;
         }

package/lib/types/AggregateFunction.ts

@@ -1,9 +1,10 @@
+import type { Field } from "./Field";
 import type { Filter } from "./Filter";
 
 /**
  * Aggregation function.
  */
-export type AggregateFunction<T extends object> =
+export type AggregateFunction<T> =
   | "length"
   | { operator: "length" }
   | { operator: "index"; filter?: Filter<T>; last?: boolean }
@@ -16,5 +17,5 @@ export type AggregateFunction<T extends object> =
         | "maximum"
         | "variance"
         | "mode";
-      field: keyof T;
+      field: Field<T>;
     };

package/lib/types/CombineUnion.ts

@@ -0,0 +1,18 @@
+import type { KeyFromUnion } from "./KeyFromUnion";
+
+export type CombineUnion<U> = [0] extends [1 & U]
+  ? any
+  : [U] extends [Function | readonly Function[]]
+    ? undefined
+    : [U] extends readonly [Array<any>]
+      ? U
+      : {
+          [K in KeyFromUnion<U>]: Continue<Combine<U, K>>;
+        };
+
+type Combine<U, K extends string | number | symbol> = Exclude<
+  Extract<U, { [k in K]?: any }>[K],
+  undefined
+>;
+
+type Continue<U> = U extends object ? CombineUnion<U> : U;

package/lib/types/Context.ts

@@ -1,3 +1,3 @@
-export type Context<T extends object> = {
+export type Context<T> = {
   [K in keyof T]?: T[K];
 };

package/lib/types/CustomFetch.ts

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

package/lib/types/CustomFieldAggregateMap.ts

@@ -1,6 +1,3 @@
 import type { AggregateFunction } from "./AggregateFunction";
 
-export type CustomFieldAggregateMap<T extends object> = Record<
-  string,
-  AggregateFunction<T>
->;
+export type CustomFieldAggregateMap<T> = Record<string, AggregateFunction<T>>;

package/lib/types/CustomFieldMap.ts

@@ -1,3 +1,3 @@
 import type { FieldFunction } from "./FieldFunction";
 
-export type CustomFieldMap<T extends object> = Record<string, FieldFunction<T>>;
+export type CustomFieldMap<T> = Record<string, FieldFunction<T>>;

package/lib/types/Field.ts

@@ -1,6 +1,6 @@
-import type { Normalized } from "./Normalized";
+import type { CombineUnion } from "./CombineUnion";
 import type { Path } from "./Path";
 
-export type Field<T> = T extends object
-  ? keyof Normalized<T> | Path<Normalized<T>>
-  : never;
+export type Field<T> = KeyOrPath<CombineUnion<T>>;
+
+type KeyOrPath<T> = keyof T | Path<T>;

package/lib/types/FieldFiltered.ts

@@ -1,7 +1,7 @@
+import type { CombineUnion } from "./CombineUnion";
 import type { KeyFiltered } from "./KeyFiltered";
-import type { Normalized } from "./Normalized";
 import type { PathFiltered } from "./PathFiltered";
 
-export type FieldFiltered<T extends object, P> =
-  | KeyFiltered<Normalized<T>, P>
-  | PathFiltered<Normalized<T>, P>;
+export type FieldFiltered<T, P> = KeyOrPathFiltered<CombineUnion<T>, P>;
+
+type KeyOrPathFiltered<T, P> = KeyFiltered<T, P> | PathFiltered<T, P>;

package/lib/types/FieldFunction.ts

@@ -1,6 +1,6 @@
 import type { FieldFunctionCustom } from "./FieldFunctionCustom";
 import type { FieldFunctionFormatDate } from "./FieldFunctionFormatDate";
 
-export type FieldFunction<T extends object> =
+export type FieldFunction<T> =
   | FieldFunctionCustom<T>
   | FieldFunctionFormatDate<T>;

package/lib/types/FieldFunctionCustom.ts

@@ -1,7 +1,7 @@
 /**
  * Applies a custom field transform function.
  */
-export type FieldFunctionCustom<T extends object> = {
+export type FieldFunctionCustom<T> = {
   operator: "custom";
   value: (item: T) => any;
 };