quetch 0.1.0

package/lib/middlewares/fetchExternal.ts

@@ -0,0 +1,38 @@
+import { getGlobal } from "@davidbonnet/get-global";
+
+import { RequestError } from "../errors/RequestError";
+import type { Handler } from "../types";
+
+/**
+ * Calls the provided `fetch` function, which defaults to the DOM `fetch` function, with the incoming `query`.
+ *
+ * @param fetch A standard `fetch` function.
+ * @returns Handler that returns a promise that resolves to the response.
+ */
+export function fetchExternal(
+  fetch = getGlobal().fetch,
+): Handler<Request, Response, never, never> {
+  if (process.env.NODE_ENV !== "production" && !fetch) {
+    console.error("Could not find a global `fetch` function");
+  }
+  return async (request, _) => {
+    try {
+      const response = await fetch(request);
+      if (!response.ok) {
+        throw new RequestError(
+          response.statusText,
+          response.status,
+          undefined,
+          request,
+          response,
+        );
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new RequestError(error.message, 500, undefined, request);
+      }
+      throw new RequestError(String(error), 500, undefined, request);
+    }
+  };
+}

package/lib/middlewares/fetchLocal.ts

@@ -0,0 +1,14 @@
+import { queryItemList } from "../tools/queryItemList";
+import type { CustomFieldMap, Handler, Query } from "../types";
+
+/**
+ * Performs the fetch query on local data.
+ *
+ * @returns Promise that resolves to the response.
+ */
+export function fetchLocal<
+  T extends object,
+  C extends CustomFieldMap<T>,
+>(): Handler<Query<T, C> & { type: T[] }, any, never, never> {
+  return async (query, _) => queryItemList<T, C>(query);
+}

package/lib/middlewares/identity.ts

@@ -0,0 +1,20 @@
+import type { NextHandler } from "../types";
+
+export async function identity<I, O, In, On>(
+  input: I,
+  next: NextHandler<In, On>,
+): Promise<O> {
+  return (await next(input as unknown as In)) as unknown as O;
+}
+
+export const identity3 = async <I, O, In, On>(
+  input: I,
+  next: NextHandler<In, On>,
+): Promise<O> => (await next(input as unknown as In)) as unknown as O;
+
+export async function identity2<I, O, In extends I, On extends O>(
+  input: In,
+  next: NextHandler<In, On>,
+): Promise<On> {
+  return await next(input);
+}

package/lib/middlewares/log.ts

@@ -0,0 +1,31 @@
+import type { Handler } from "../types";
+
+import { identity } from "./identity";
+
+/**
+ * Logs the outgoing query and the incoming result or the error.
+ *
+ * @param title
+ * @returns Query handler
+ */
+export function log<I, O, In, On>(title = "Query"): Handler<I, O, In, On> {
+  if (process.env.NODE_ENV === "production") {
+    return identity;
+  }
+  return async (input, next) => {
+    /* eslint-disable no-console */
+    console.group(title);
+    console.info("query", input);
+    try {
+      const result = await next(input as unknown as In);
+      console.log("result", result);
+      console.groupEnd();
+      return result as unknown as O;
+    } catch (error) {
+      console.log("error", error);
+      console.groupEnd();
+      throw error;
+    }
+    /* eslint-enable no-console */
+  };
+}

package/lib/middlewares/retry.ts

@@ -0,0 +1,45 @@
+import { getGlobal } from "@davidbonnet/get-global";
+import { sleep, untilOnline } from "futurise";
+
+import { RequestError } from "../errors/RequestError";
+import type { Handler } from "../types";
+
+/**
+ * Retries a failed query call up to `amount` times, with a given `delay` in milliseconds at ±`delayDelta` milliseconds.
+ * Note that an `amount` set to `Infinity` results in indefinitely trying to resolve a query call.
+ * Only instances of `RequestError` that do not result in a `500` status error will result in new tries. Other errors will propagate immediately.
+ *
+ * @param options
+ * @returns Handler
+ */
+export function retry({
+  amount = 5,
+  delay = 1000,
+  delayDelta = 500,
+} = {}): Handler<Request, Response, Request, Response> {
+  const { navigator } = getGlobal();
+  return (input, next) => {
+    let errorsLeft = amount;
+    const fetch = async (): Promise<Response> => {
+      try {
+        return await next(input);
+      } catch (error) {
+        if (navigator !== undefined && !navigator.onLine) {
+          errorsLeft = amount;
+          await untilOnline();
+        } else if (!(error instanceof RequestError) || error.status < 500) {
+          throw error;
+        }
+        if (--errorsLeft > 0) {
+          await sleep(
+            delay + delayDelta + ((Math.random() * delayDelta * 2) | 0),
+            input.signal,
+          );
+          return fetch();
+        }
+        throw error;
+      }
+    };
+    return fetch();
+  };
+}

package/lib/middlewares.ts

@@ -0,0 +1,10 @@
+// File automatically generated by `vite-plugin-module-list`
+export { aggregate } from "./middlewares/aggregate";
+export { branch } from "./middlewares/branch";
+export { cache } from "./middlewares/cache";
+export { combine } from "./middlewares/combine";
+export { fetchExternal } from "./middlewares/fetchExternal";
+export { fetchLocal } from "./middlewares/fetchLocal";
+export { identity } from "./middlewares/identity";
+export { log } from "./middlewares/log";
+export { retry } from "./middlewares/retry";

package/lib/tools/defineCheckQuery.ts

@@ -0,0 +1,24 @@
+import type { CustomFieldMap, Query } from "../types";
+
+export function defineCheckQuery<Entities extends Record<string, object>>() {
+  function checkQuery<
+    E extends object,
+    C extends CustomFieldMap<E>,
+    const Q extends Query<E, C>,
+  >(query: Q & { type: E[]; customFields?: C }): typeof query;
+  function checkQuery<
+    T extends keyof Entities,
+    E extends Entities[T],
+    C extends CustomFieldMap<E>,
+    const Q extends Query<E, C>,
+  >(query: Q & { type: T; customFields?: C }): typeof query;
+  function checkQuery<
+    T extends keyof Entities,
+    E extends Entities[T] | object,
+    C extends CustomFieldMap<E>,
+    const Q extends Query<E, C>,
+  >(query: Q & { type: T | E[]; customFields?: C }): typeof query {
+    return query;
+  }
+  return checkQuery;
+}

package/lib/tools/defineCustomFetch.ts

@@ -0,0 +1,70 @@
+import type {
+  AnyQuery,
+  CustomFieldMap,
+  EntityItem,
+  Handler,
+  Query,
+} from "../types";
+
+import { impasse } from "./impasse";
+
+export function defineCustomFetch<M extends Record<string, object>>(
+  handler: Handler<AnyQuery, any, never, never>,
+) {
+  function customFetch<
+    E extends object,
+    C extends CustomFieldMap<E>,
+    const Q extends Query<E, C>,
+  >(
+    input: Q & { type: E[]; customFields?: C },
+  ): Promise<
+    Q["method"] extends "get"
+      ? Q extends { multiple: true }
+        ? EntityItem<E, C, Q>[]
+        : EntityItem<E, C, Q>
+      : Q["method"] extends "aggregate"
+      ? number
+      : Q extends { multiple: true }
+      ? EntityItem<E, C, Q>[]
+      : EntityItem<E, C, Q>
+  >;
+  function customFetch<
+    T extends keyof M,
+    E extends M[T],
+    C extends CustomFieldMap<E>,
+    const Q extends Query<E, C>,
+  >(
+    input: Q & { type: T; customFields?: C },
+  ): Promise<
+    Q["method"] extends "get"
+      ? Q extends { multiple: true }
+        ? EntityItem<E, C, Q>[]
+        : EntityItem<E, C, Q>
+      : Q["method"] extends "aggregate"
+      ? number
+      : Q extends { multiple: true }
+      ? EntityItem<E, C, Q>[]
+      : EntityItem<E, C, Q>
+  >;
+  async function customFetch<
+    T extends keyof M,
+    E extends M[T] | object,
+    C extends CustomFieldMap<E>,
+    const Q extends Query<E, C>,
+  >(
+    input: Q & { type: T | E[]; customFields?: C },
+  ): Promise<
+    Q["method"] extends "get"
+      ? Q extends { multiple: true }
+        ? EntityItem<E, C, Q>[]
+        : EntityItem<E, C, Q>
+      : Q["method"] extends "aggregate"
+      ? number
+      : Q extends { multiple: true }
+      ? EntityItem<E, C, Q>[]
+      : EntityItem<E, C, Q>
+  > {
+    return await handler(input, impasse);
+  }
+  return customFetch;
+}

package/lib/tools/filterFromContext.ts

@@ -0,0 +1,16 @@
+import type { Context, Filter } from "../types";
+
+const { entries } = Object;
+
+export function filterFromContext<T extends object>(
+  context: Context<T>,
+): Filter<T> {
+  return {
+    operator: "all",
+    value: entries(context).map(([field, value]) => ({
+      operator: "equal",
+      field,
+      value,
+    })) as Filter<T>[],
+  };
+}

package/lib/tools/filterItem.test.ts

@@ -0,0 +1,203 @@
+import { expect, test } from "vitest";
+
+import { filterItem } from "./filterItem";
+
+test("tests filter lists", () => {
+  expect(
+    filterItem(
+      {
+        operator: "all",
+        value: [
+          { operator: "equal", field: "a", value: "foo" },
+          { operator: "equal", field: "b", value: "bar" },
+        ],
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      {
+        operator: "all",
+        value: [
+          { operator: "equal", field: "a", value: "foo" },
+          { operator: "equal", field: "b", value: "baz" },
+        ],
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeFalsy();
+  expect(
+    filterItem(
+      {
+        operator: "all",
+        value: [],
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      {
+        operator: "any",
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      {
+        operator: "none",
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeFalsy();
+  expect(
+    filterItem(
+      {
+        operator: "any",
+        value: [
+          { operator: "equal", field: "a", value: "foo" },
+          { operator: "equal", field: "b", value: "baz" },
+        ],
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      {
+        operator: "none",
+        value: [
+          { operator: "equal", field: "a", value: "a" },
+          { operator: "equal", field: "b", value: "b" },
+        ],
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      {
+        operator: "none",
+        value: [
+          { operator: "equal", field: "a", value: "a" },
+          { operator: "equal", field: "b", value: "b" },
+        ],
+      },
+      { a: "foo", b: "bar" },
+    ),
+  ).toBeTruthy();
+});
+
+test("tests filter on string values", () => {
+  expect(
+    filterItem({ operator: "equal", field: "a", value: "foo" }, { a: "foo" }),
+  ).toBeTruthy();
+  expect(
+    filterItem({ operator: "equal", field: "a", value: "bar" }, { a: "foo" }),
+  ).toBeFalsy();
+  expect(
+    filterItem(
+      { operator: "notEqual", field: "a", value: "bar" },
+      { a: "foo" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "include", field: "a", value: "bar" },
+      { a: "foobar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "intersect", field: "a", value: ["foo", "bar", "foobar"] },
+      { a: "foobar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "intersect", field: "a", value: ["foo", "bar"] },
+      { a: "foobar" },
+    ),
+  ).toBeFalsy();
+  expect(
+    filterItem(
+      {
+        operator: "match",
+        field: "a",
+        value: "^FOO",
+        options: { ignoreCase: true },
+      },
+      { a: "foobar" },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      {
+        operator: "match",
+        field: "a",
+        value: "FOO$",
+        options: { ignoreCase: true },
+      },
+      { a: "foobar" },
+    ),
+  ).toBeFalsy();
+});
+
+test("tests filter on number values", () => {
+  expect(
+    filterItem({ operator: "equal", field: "a", value: 1 }, { a: 1 }),
+  ).toBeTruthy();
+  expect(
+    filterItem({ operator: "notEqual", field: "a", value: 2 }, { a: 1 }),
+  ).toBeTruthy();
+  expect(
+    filterItem({ operator: "greaterThan", field: "a", value: 0 }, { a: 1 }),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "greaterThanOrEqual", field: "a", value: 1 },
+      { a: 1 },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem({ operator: "lowerThan", field: "a", value: 2 }, { a: 1 }),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "lowerThanOrEqual", field: "a", value: 1 },
+      { a: 1 },
+    ),
+  ).toBeTruthy();
+});
+
+test("tests filter on array values", () => {
+  expect(
+    filterItem({ operator: "equal", field: "a", value: [2, 1] }, { a: [1, 2] }),
+  ).toBeTruthy();
+  expect(
+    filterItem({ operator: "equal", field: "a", value: [2] }, { a: [1, 2] }),
+  ).toBeFalsy();
+  expect(
+    filterItem({ operator: "include", field: "a", value: [1] }, { a: [1, 2] }),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "include", field: "a", value: [2, 3] },
+      { a: [1, 2] },
+    ),
+  ).toBeFalsy();
+  expect(
+    filterItem(
+      { operator: "intersect", field: "a", value: [2, 3] },
+      { a: [1, 2] },
+    ),
+  ).toBeTruthy();
+  expect(
+    filterItem(
+      { operator: "intersect", field: "a", value: [3, 4] },
+      { a: [1, 2] },
+    ),
+  ).toBeFalsy();
+});

package/lib/tools/filterItem.ts

@@ -0,0 +1,113 @@
+import type { Any, Filter } from "../types";
+
+const { isArray } = Array;
+
+/**
+ * Checks wether the provided `value` matches the `filter` or not.
+ *
+ * @param filter The filter to apply.
+ * @param value The value to check.
+ * @returns `true` if the `value` matches the `filter` and `false` otherwise.
+ */
+export function filterItem<T extends object>(
+  filter: Filter<T> | undefined,
+  value: T | undefined,
+): boolean {
+  if (value === undefined) {
+    return false;
+  }
+  if (filter === undefined) {
+    return true;
+  }
+  switch (filter.operator) {
+    case "all":
+      return filter.value.every((filter) => filterItem(filter, value));
+    case "any": {
+      if (filter.value === undefined || filter.value.length === 0) {
+        return true;
+      }
+      return filter.value.some((filter) => filterItem(filter, value));
+    }
+    case "none": {
+      if (filter.value === undefined || filter.value.length === 0) {
+        return false;
+      }
+      return filter.value.every((filter) => !filterItem(filter, value));
+    }
+    case "exist":
+      // TODO: Handle path
+      return filter.field in value;
+    case "equal": {
+      if (isArray(filter.value)) {
+        const item = value[filter.field] as Any[] | undefined;
+        if (!isArray(item)) {
+          return false;
+        }
+        if (filter.value.length !== item.length) {
+          return false;
+        }
+        return filter.value.every((value) => item.includes(value));
+      }
+      return value[filter.field] === filter.value;
+    }
+    case "notEqual":
+      return value[filter.field] !== filter.value;
+    case "startWith":
+      return (
+        (value[filter.field] as string | undefined)?.startsWith(filter.value) ??
+        false
+      );
+    case "endWith":
+      return (
+        (value[filter.field] as string | undefined)?.endsWith(filter.value) ??
+        false
+      );
+    case "include": {
+      const item = value[filter.field];
+      if (item === undefined) {
+        return false;
+      }
+      if (isArray(filter.value)) {
+        if (!isArray(item)) {
+          return false;
+        }
+        return filter.value.every((value) => item.includes(value));
+      }
+      return (item as string).includes?.(filter.value) ?? false;
+    }
+    case "greaterThan":
+      return value[filter.field] > filter.value;
+    case "greaterThanOrEqual":
+      return value[filter.field] >= filter.value;
+    case "lowerThan":
+      return value[filter.field] < filter.value;
+    case "lowerThanOrEqual":
+      return value[filter.field] <= filter.value;
+    case "match": {
+      const item = value[filter.field] as string | undefined;
+      if (item === undefined) {
+        return false;
+      }
+      if (filter.regularExpression === undefined) {
+        const { options = {} } = filter;
+        filter.regularExpression = new RegExp(
+          filter.value,
+          `${options.ignoreCase ? "i" : ""}${options.dotAll ? "s" : ""}`,
+        );
+      }
+      return filter.regularExpression.test(item);
+    }
+    case "intersect": {
+      const item = value[filter.field];
+      if (item === undefined) {
+        return false;
+      }
+      if (isArray(item)) {
+        return filter.value.some((value) => item?.includes(value));
+      }
+      return filter.value.includes(item as string);
+    }
+    default:
+      throw new Error(`Unknown filter operator '${(filter as any).operator}'`);
+  }
+}

package/lib/tools/impasse.ts

@@ -0,0 +1,3 @@
+import type { NextHandler } from "../types";
+
+export const impasse = undefined as unknown as NextHandler<never, never>;

package/lib/tools/normalizeOrder.ts

@@ -0,0 +1,13 @@
+import type { Order } from "../types";
+
+export function normalizeOrder<T extends object>(
+  order: Order<T>,
+): { field: keyof T; descending?: boolean } {
+  if (typeof order === "object") {
+    return order;
+  }
+  return {
+    field: order,
+    descending: false,
+  };
+}