quetch 0.1.0

package/lib/tools/queryItemList.test.ts

@@ -0,0 +1,169 @@
+import { expect, test } from "vitest";
+
+import { queryItemList } from "./queryItemList";
+
+test("queries a single item", () => {
+  expect(
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+    }),
+  ).toEqual({ a: 1 });
+  expect(() =>
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+      context: {
+        a: 4,
+      },
+    }),
+  ).toThrow("Not found");
+  expect(
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+      filter: {
+        field: "a",
+        operator: "greaterThan",
+        value: 1,
+      },
+    }),
+  ).toEqual({ a: 2 });
+  expect(() =>
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+      filter: {
+        field: "a",
+        operator: "greaterThanOrEqual",
+        value: 4,
+      },
+    }),
+  ).toThrow("Not found");
+});
+
+test("queries lists of items", () => {
+  expect(
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+      multiple: true,
+    }),
+  ).toEqual([{ a: 1 }, { a: 2 }, { a: 3 }]);
+  expect(
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+      multiple: true,
+      filter: {
+        field: "a",
+        operator: "greaterThan",
+        value: 1,
+      },
+    }),
+  ).toEqual([{ a: 2 }, { a: 3 }]);
+  expect(
+    queryItemList({
+      type: [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+      ],
+      method: "get",
+      multiple: true,
+      context: {
+        c: "a",
+      },
+      filter: {
+        field: "a",
+        operator: "greaterThan",
+        value: 1,
+      },
+    }),
+  ).toEqual([{ a: 2, c: "a" }]);
+  expect(
+    queryItemList({
+      type: [{ a: 1 }, { a: 2 }, { a: 3 }],
+      multiple: true,
+      filter: {
+        field: "a",
+        operator: "greaterThanOrEqual",
+        value: 4,
+      },
+    }),
+  ).toEqual([]);
+});
+
+test("sorts items", () => {
+  expect(
+    queryItemList({
+      type: [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+        { a: 2, c: "b" },
+        { a: 1, c: "b" },
+      ],
+      multiple: true,
+      orderBy: ["a", "c"],
+    }),
+  ).toEqual([
+    { a: 1, c: "a" },
+    { a: 1, c: "b" },
+    { a: 2, c: "a" },
+    { a: 2, c: "b" },
+    { a: 3, c: "b" },
+  ]);
+  expect(
+    queryItemList({
+      type: [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+        { a: 2, c: "b" },
+        { a: 1, c: "b" },
+      ],
+      multiple: true,
+      orderBy: [
+        { field: "a", descending: true },
+        { field: "c", descending: true },
+      ],
+    }),
+  ).toEqual([
+    { a: 3, c: "b" },
+    { a: 2, c: "b" },
+    { a: 2, c: "a" },
+    { a: 1, c: "b" },
+    { a: 1, c: "a" },
+  ]);
+});
+
+test("aggregates items", () => {
+  expect(
+    queryItemList({
+      type: [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+      ],
+      method: "aggregate",
+      aggregator: "length",
+      context: {
+        c: "a",
+      },
+    }),
+  ).toBe(2);
+  expect(
+    queryItemList({
+      type: [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+      ],
+      method: "aggregate",
+      aggregator: "length",
+      context: {
+        c: "a",
+      },
+      filter: {
+        field: "a",
+        operator: "greaterThan",
+        value: 1,
+      },
+    }),
+  ).toBe(1);
+});

package/lib/tools/queryItemList.ts

@@ -0,0 +1,108 @@
+import { RequestError } from "../errors";
+import type {
+  AggregateFunction,
+  AggregateFunctionOperator,
+  Context,
+  CustomFieldMap,
+  Filter,
+  Order,
+  Query,
+} from "../types";
+
+import { filterFromContext } from "./filterFromContext";
+import { filterItem } from "./filterItem";
+import { sortItemList } from "./sortItemList";
+
+function mergeContextAndFilter<T extends object>(
+  context?: Context<T>,
+  filter?: Filter<T>,
+): Filter<T> {
+  if (context === undefined) {
+    return filter ?? { operator: "any" };
+  }
+  if (filter === undefined) {
+    return filterFromContext(context);
+  }
+  return {
+    operator: "all",
+    value: [filterFromContext(context), filter],
+  };
+}
+
+function normalizeAggregator<T extends object>(
+  aggregator: AggregateFunction<T>,
+): AggregateFunctionOperator {
+  if (aggregator === "length") {
+    return aggregator;
+  }
+  return aggregator.operator;
+}
+
+export function queryItemList<T extends object, C extends CustomFieldMap<T>>(
+  query: Query<T, C> & { type: T[] },
+) {
+  const data = query.type as T[];
+  switch (query.method) {
+    case "get":
+    case undefined: {
+      const { filter, context } = query;
+      if (query.multiple) {
+        const { offset = 0, limit = Infinity, orderBy } = query;
+        // Filter
+        let result = data;
+        if (context !== undefined || filter !== undefined) {
+          const normalizedFilter = mergeContextAndFilter(
+            context,
+            filter as Filter<T>,
+          );
+          result = data.filter((item) => filterItem(normalizedFilter, item));
+        }
+        // Sort
+        result = sortItemList(
+          orderBy as Order<T>[],
+          result === data ? [...data] : result,
+        );
+        // Slice
+        if (offset !== 0 || limit !== Infinity) {
+          result = result.slice(offset, offset + limit);
+        }
+        return result;
+      }
+      const normalizedFilter = mergeContextAndFilter(
+        context,
+        filter as Filter<T>,
+      );
+      const result = data.find((item) => filterItem(normalizedFilter, item));
+      if (result === undefined) {
+        throw new RequestError("Not found", 404, query);
+      }
+      return result;
+    }
+    case "aggregate": {
+      const { context, filter, aggregator } = query;
+      switch (normalizeAggregator(aggregator)) {
+        case "length": {
+          if (filter === undefined && context === undefined) {
+            return data.length;
+          }
+          const normalizedFilter = mergeContextAndFilter(
+            context,
+            filter as Filter<T>,
+          );
+          return data.reduce((result, item) => {
+            if (filterItem(normalizedFilter, item)) {
+              return result + 1;
+            }
+            return result;
+          }, 0);
+        }
+        default: {
+          throw new Error("Not implemented");
+        }
+      }
+    }
+    default: {
+      throw new Error(`Unknown query method '${query.method}'`);
+    }
+  }
+}

package/lib/tools/sortItemList.test.ts

@@ -0,0 +1,63 @@
+import { expect, test } from "vitest";
+
+import { sortItemList } from "./sortItemList";
+
+test("sorts items", () => {
+  expect(
+    sortItemList(
+      ["a", "c"],
+      [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+        { a: 2, c: "b" },
+        { a: 1, c: "b" },
+      ],
+    ),
+  ).toEqual([
+    { a: 1, c: "a" },
+    { a: 1, c: "b" },
+    { a: 2, c: "a" },
+    { a: 2, c: "b" },
+    { a: 3, c: "b" },
+  ]);
+  expect(
+    sortItemList(
+      [
+        { field: "a", descending: true },
+        { field: "c", descending: true },
+      ],
+      [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+        { a: 2, c: "b" },
+        { a: 1, c: "b" },
+      ],
+    ),
+  ).toEqual([
+    { a: 3, c: "b" },
+    { a: 2, c: "b" },
+    { a: 2, c: "a" },
+    { a: 1, c: "b" },
+    { a: 1, c: "a" },
+  ]);
+  expect(
+    sortItemList(
+      ["a", { field: "c", descending: true }],
+      [
+        { a: 1, c: "a" },
+        { a: 2, c: "a" },
+        { a: 3, c: "b" },
+        { a: 2, c: "b" },
+        { a: 1, c: "b" },
+      ],
+    ),
+  ).toEqual([
+    { a: 1, c: "b" },
+    { a: 1, c: "a" },
+    { a: 2, c: "b" },
+    { a: 2, c: "a" },
+    { a: 3, c: "b" },
+  ]);
+});

package/lib/tools/sortItemList.ts

@@ -0,0 +1,33 @@
+import type { Order } from "../types";
+
+import { normalizeOrder } from "./normalizeOrder";
+
+/**
+ * Sorts provided `value` array *in place* according to the `orderList`.
+ *
+ * @param orderList The order to use for sorting.
+ * @param value The array to sort.
+ * @returns The same array sorted in place.
+ */
+export function sortItemList<T extends object>(
+  orderList: Order<T>[] | undefined,
+  value: T[],
+) {
+  if (orderList === undefined || orderList.length === 0) {
+    return value;
+  }
+  const normalizedOrderBy = orderList.map(normalizeOrder);
+  return value.sort((a, b) => {
+    for (let index = 0; index < normalizedOrderBy.length; index++) {
+      const { field, descending } = normalizedOrderBy[index];
+      if (a[field] === b[field]) {
+        continue;
+      }
+      if (a[field] > b[field]) {
+        return descending ? -1 : 1;
+      }
+      return descending ? 1 : -1;
+    }
+    return 0;
+  });
+}

package/lib/tools.ts

@@ -0,0 +1,9 @@
+// File automatically generated by `vite-plugin-module-list`
+export { defineCheckQuery } from "./tools/defineCheckQuery";
+export { defineCustomFetch } from "./tools/defineCustomFetch";
+export { filterFromContext } from "./tools/filterFromContext";
+export { filterItem } from "./tools/filterItem";
+export { impasse } from "./tools/impasse";
+export { normalizeOrder } from "./tools/normalizeOrder";
+export { queryItemList } from "./tools/queryItemList";
+export { sortItemList } from "./tools/sortItemList";