feathers-utils 5.1.0 → 6.0.0

package/src/utils/filterQuery.ts

@@ -1,6 +1,6 @@
 import type { Query } from "@feathersjs/feathers";
 
-type FilterQueryResult<Q extends Query> = {
+type FilterQueryResult<Q extends Query = Query> = {
   $select: Q["$select"] extends any ? Q["$select"] : never;
   $limit: Q["$limit"] extends any ? Q["$limit"] : never;
   $skip: Q["$skip"] extends any ? Q["$skip"] : never;
@@ -41,58 +41,130 @@ export function filterQuery<Q extends Query>(
   return result;
 }
 
+export function reassembleQuery(query: FilterQueryResult): Query {
+  const { $select, $limit, $skip, $sort, query: rest } = query;
+
+  const result: Query = rest;
+
+  if ($select !== undefined) {
+    result.$select = $select;
+  }
+
+  if ($limit !== undefined) {
+    result.$limit = $limit;
+  }
+
+  if ($skip !== undefined) {
+    result.$skip = $skip;
+  }
+
+  if ($sort !== undefined) {
+    result.$sort = $sort;
+  }
+
+  return result;
+}
+
 if (import.meta.vitest) {
-  const { it, expect } = import.meta.vitest;
-
-  it("should filter query", () => {
-    const query = {
-      $select: ["a"],
-      $limit: 10,
-      $skip: 10,
-      $sort: {
-        a: 1,
-      },
-      a: 1,
-      b: 2,
-    };
-
-    expect(filterQuery(query)).toEqual({
-      $select: ["a"],
-      $limit: 10,
-      $skip: 10,
-      $sort: {
+  const { describe, it, expect } = import.meta.vitest;
+
+  describe("filterQuery", () => {
+    it("should filter query", () => {
+      const query = {
+        $select: ["a"],
+        $limit: 10,
+        $skip: 10,
+        $sort: {
+          a: 1,
+        },
         a: 1,
-      },
-      query: {
+        b: 2,
+      };
+
+      expect(filterQuery(query)).toEqual({
+        $select: ["a"],
+        $limit: 10,
+        $skip: 10,
+        $sort: {
+          a: 1,
+        },
+        query: {
+          a: 1,
+          b: 2,
+        },
+      });
+    });
+
+    it("should not include filters if not provided", () => {
+      const query = {
         a: 1,
         b: 2,
-      },
+      };
+
+      expect(filterQuery(query)).toEqual({
+        query: {
+          a: 1,
+          b: 2,
+        },
+      });
     });
-  });
 
-  it("should not include filters if not provided", () => {
-    const query = {
-      a: 1,
-      b: 2,
-    };
+    it("sets empty query object if empty object is provided", () => {
+      expect(filterQuery({})).toEqual({
+        query: {},
+      });
+    });
+
+    it("sets empty query object if undefined is provided", () => {
+      expect(filterQuery(undefined)).toEqual({
+        query: {},
+      });
+    });
+  });
 
-    expect(filterQuery(query)).toEqual({
-      query: {
+  describe("reassembleQuery", () => {
+    it("should filter query", () => {
+      expect(
+        reassembleQuery(
+          filterQuery({
+            $select: ["a"],
+            $limit: 10,
+            $skip: 10,
+            $sort: {
+              a: 1,
+            },
+            a: 1,
+            b: 2,
+          }),
+        ),
+      ).toEqual({
+        $select: ["a"],
+        $limit: 10,
+        $skip: 10,
+        $sort: {
+          a: 1,
+        },
         a: 1,
         b: 2,
-      },
+      });
     });
-  });
 
-  it("sets empty query object if empty object is provided", () => {
-    expect(filterQuery({})).toEqual({
-      query: {},
+    it("should not include filters if not provided", () => {
+      expect(
+        reassembleQuery(
+          filterQuery({
+            a: 1,
+            b: 2,
+          }),
+        ),
+      ).toEqual({
+        a: 1,
+        b: 2,
+      });
     });
-  });
 
-  it("sets empty query object if undefined is provided", () => {
-    expect(filterQuery(undefined)).toEqual({
-      query: {},
+    it("sets empty query object if empty object is provided", () => {
+      expect(reassembleQuery(filterQuery({}))).toEqual({});
     });
   });
 }

package/src/utils/flattenQuery.ts

@@ -0,0 +1,198 @@
+import type { Query } from "@feathersjs/feathers";
+import { filterQuery, reassembleQuery } from "./filterQuery";
+import _set from "lodash/set.js";
+import { isObject } from "./_utils.internal";
+
+export function flattenQuery(q: Query) {
+  if (Array.isArray(q)) {
+    return q.map(flattenQuery);
+  }
+
+  if (!isObject(q)) {
+    return q;
+  }
+
+  const { query, $limit, $select, $skip, $sort } = filterQuery(q);
+
+  type StepOptions = {
+    prev?: string[];
+    result?: Query;
+  };
+
+  const res = {};
+
+  function step(object: Query, options?: StepOptions) {
+    const { prev = [], result = res } = options ?? {};
+
+    Object.keys(object).forEach((key) => {
+      const value = object[key];
+      if (Array.isArray(value)) {
+        const newValues = value.map((v) =>
+          step(v, {
+            result: {},
+          }),
+        );
+        _set(result, [...prev, key], newValues);
+        return;
+      }
+
+      if (key.startsWith("$")) {
+        _set(result, [...prev, key], value);
+        return;
+      }
+
+      const newKey = !prev.length
+        ? [key]
+        : [...prev.slice(0, -1), `${prev[prev.length - 1]}.${key}`];
+
+      if (!isObject(value)) {
+        _set(result, newKey, value);
+        return;
+      } else {
+        step(value, {
+          prev: newKey,
+          result,
+        });
+        return;
+      }
+    });
+
+    return result;
+  }
+
+  return reassembleQuery({
+    $limit,
+    $select,
+    $skip,
+    $sort,
+    query: step(query),
+  });
+}
+
+if (import.meta.vitest) {
+  const { describe, it, expect } = import.meta.vitest;
+
+  describe("flattenQuery", () => {
+    it("should flatten a query", () => {
+      expect(
+        flattenQuery({
+          a: 1,
+          b: {
+            c: 1,
+            d: 1,
+          },
+          e: {
+            f: {
+              g: 1,
+            },
+          },
+        }),
+      ).toEqual({
+        a: 1,
+        "b.c": 1,
+        "b.d": 1,
+        "e.f.g": 1,
+      });
+    });
+  });
+
+  it("should handle operators", () => {
+    expect(
+      flattenQuery({
+        a: {
+          b: 1,
+        },
+        c: {
+          $gt: 1,
+          $lte: 1,
+        },
+      }),
+    ).toEqual({
+      "a.b": 1,
+      c: {
+        $gt: 1,
+        $lte: 1,
+      },
+    });
+  });
+
+  it("should handle $or / $and", () => {
+    expect(
+      flattenQuery({
+        a: {
+          b: 1,
+        },
+        $and: [
+          {
+            c: {
+              d: 1,
+            },
+          },
+        ],
+        $or: [
+          {
+            e: {
+              f: 1,
+            },
+          },
+        ],
+      }),
+    ).toEqual({
+      "a.b": 1,
+      $and: [
+        {
+          "c.d": 1,
+        },
+      ],
+      $or: [
+        {
+          "e.f": 1,
+        },
+      ],
+    });
+  });
+
+  it("should handle nested $or / $and with operators", () => {
+    expect(
+      flattenQuery({
+        a: {
+          b: 1,
+        },
+        $and: [
+          {
+            $or: [
+              {
+                c1: {
+                  d1: 1,
+                },
+              },
+              {
+                c2: {
+                  d2: {
+                    $gt: 1,
+                  },
+                },
+              },
+            ],
+          },
+        ],
+      }),
+    ).toEqual({
+      "a.b": 1,
+      $and: [
+        {
+          $or: [
+            {
+              "c1.d1": 1,
+            },
+            {
+              "c2.d2": {
+                $gt: 1,
+              },
+            },
+          ],
+        },
+      ],
+    });
+  });
+}

package/src/utils/getItemsIsArray.ts

@@ -41,3 +41,282 @@ export const getItemsIsArray = <T = any, H extends HookContext = HookContext>(
     isArray,
   };
 };
+
+if (import.meta.vitest) {
+  const { describe, it, assert } = import.meta.vitest;
+
+  const assertBefore = (context, items, isArray) => {
+    const arrays: (GetItemsIsArrayFrom | undefined)[] = [
+      undefined,
+      "data",
+      "automatic",
+    ];
+
+    for (const from of arrays) {
+      const { items: items2, isArray: isArray2 } = getItemsIsArray(context, {
+        from,
+      });
+      assert.deepStrictEqual(items2, items, `from: ${from}`);
+      assert.deepStrictEqual(isArray2, isArray, `from: ${from}`);
+    }
+  };
+
+  const assertAfter = (context, items, isArray) => {
+    const arrays: (GetItemsIsArrayFrom | undefined)[] = [
+      undefined,
+      "result",
+      "automatic",
+    ];
+
+    for (const from of arrays) {
+      const { items: items2, isArray: isArray2 } = getItemsIsArray(context, {
+        from,
+      });
+      assert.deepStrictEqual(items2, items, `from: ${from}`);
+      assert.deepStrictEqual(isArray2, isArray, `from: ${from}`);
+    }
+  };
+
+  describe("before", function () {
+    it("find:before", async function () {
+      const context = {
+        type: "before",
+        method: "find",
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+
+    it("get:before", async function () {
+      const context = {
+        type: "before",
+        method: "get",
+        id: 1,
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+
+    it("create:before single", async function () {
+      const context = {
+        type: "before",
+        method: "create",
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("create:before multi", async function () {
+      const context = {
+        type: "before",
+        method: "create",
+        data: [{ test: true }, { test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }, { test: true }], true);
+    });
+
+    it("update:before single", async function () {
+      const context = {
+        type: "before",
+        method: "update",
+        id: 1,
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("patch:before single", async function () {
+      const context = {
+        type: "before",
+        method: "patch",
+        id: 1,
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("patch:before multi", async function () {
+      const context = {
+        type: "before",
+        method: "patch",
+        id: null,
+        data: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [{ test: true }], false);
+    });
+
+    it("remove:before single", async function () {
+      const context = {
+        type: "before",
+        method: "remove",
+        id: 1,
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+
+    it("remove:before multi", async function () {
+      const context = {
+        type: "before",
+        method: "remove",
+        id: null,
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertBefore(context, [], false);
+    });
+  });
+
+  describe("after", function () {
+    it("find:after paginate:true", function () {
+      const context = {
+        type: "after",
+        method: "find",
+        result: {
+          total: 1,
+          skip: 0,
+          limit: 10,
+          data: [{ test: true }],
+        },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], true);
+    });
+
+    it("find:after paginate:false", function () {
+      const context = {
+        type: "after",
+        method: "find",
+        result: [{ test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], true);
+    });
+
+    it("get:after", function () {
+      const context = {
+        type: "after",
+        method: "get",
+        id: 1,
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("update:after", function () {
+      const context = {
+        type: "after",
+        method: "update",
+        id: 1,
+        data: { test: "yes" },
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("patch:after single", function () {
+      const context = {
+        type: "after",
+        method: "patch",
+        id: 1,
+        data: { test: "yes" },
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("patch:after multi", function () {
+      const context = {
+        type: "after",
+        method: "patch",
+        id: null,
+        data: { test: "yes" },
+        result: [{ test: true }, { test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }, { test: true }], true);
+    });
+
+    it("remove:after single", function () {
+      const context = {
+        type: "after",
+        method: "remove",
+        id: 1,
+        data: { test: "yes" },
+        result: { test: true },
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }], false);
+    });
+
+    it("remove:after multi", function () {
+      const context = {
+        type: "after",
+        method: "remove",
+        id: null,
+        data: { test: "yes" },
+        result: [{ test: true }, { test: true }],
+        params: {
+          query: {},
+        },
+      } as any as HookContext;
+
+      assertAfter(context, [{ test: true }, { test: true }], true);
+    });
+  });
+}