feathers-utils 6.0.0 → 7.0.1

package/src/utils/filterQuery.ts

@@ -1,12 +1,12 @@
-import type { Query } from "@feathersjs/feathers";
+import type { Query } from '@feathersjs/feathers'
 
 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;
-  $sort: Q["$sort"] extends any ? Q["$sort"] : never;
-  query: Omit<Q, "$select" | "$limit" | "$skip" | "$sort">;
-};
+  $select: Q['$select'] extends any ? Q['$select'] : never
+  $limit: Q['$limit'] extends any ? Q['$limit'] : never
+  $skip: Q['$skip'] extends any ? Q['$skip'] : never
+  $sort: Q['$sort'] extends any ? Q['$sort'] : never
+  query: Omit<Q, '$select' | '$limit' | '$skip' | '$sort'>
+}
 
 /**
  * Extracts $select, $limit, $skip, $sort from a query and returns the rest as a query object.
@@ -17,61 +17,61 @@ type FilterQueryResult<Q extends Query = Query> = {
 export function filterQuery<Q extends Query>(
   providedQuery?: Q,
 ): FilterQueryResult<Q> {
-  providedQuery ??= {} as Q;
-  const { $select, $limit, $skip, $sort, ...query } = providedQuery;
+  providedQuery ??= {} as Q
+  const { $select, $limit, $skip, $sort, ...query } = providedQuery
 
-  const result: FilterQueryResult<Q> = { query } as any;
+  const result: FilterQueryResult<Q> = { query } as any
 
-  if ("$select" in providedQuery) {
-    result.$select = $select;
+  if ('$select' in providedQuery) {
+    result.$select = $select
   }
 
-  if ("$limit" in providedQuery) {
-    result.$limit = $limit;
+  if ('$limit' in providedQuery) {
+    result.$limit = $limit
   }
 
-  if ("$skip" in providedQuery) {
-    result.$skip = $skip;
+  if ('$skip' in providedQuery) {
+    result.$skip = $skip
   }
 
-  if ("$sort" in providedQuery) {
-    result.$sort = $sort;
+  if ('$sort' in providedQuery) {
+    result.$sort = $sort
   }
 
-  return result;
+  return result
 }
 
 export function reassembleQuery(query: FilterQueryResult): Query {
-  const { $select, $limit, $skip, $sort, query: rest } = query;
+  const { $select, $limit, $skip, $sort, query: rest } = query
 
-  const result: Query = rest;
+  const result: Query = rest
 
   if ($select !== undefined) {
-    result.$select = $select;
+    result.$select = $select
   }
 
   if ($limit !== undefined) {
-    result.$limit = $limit;
+    result.$limit = $limit
   }
 
   if ($skip !== undefined) {
-    result.$skip = $skip;
+    result.$skip = $skip
   }
 
   if ($sort !== undefined) {
-    result.$sort = $sort;
+    result.$sort = $sort
   }
 
-  return result;
+  return result
 }
 
 if (import.meta.vitest) {
-  const { describe, it, expect } = import.meta.vitest;
+  const { describe, it, expect } = import.meta.vitest
 
-  describe("filterQuery", () => {
-    it("should filter query", () => {
+  describe('filterQuery', () => {
+    it('should filter query', () => {
       const query = {
-        $select: ["a"],
+        $select: ['a'],
         $limit: 10,
         $skip: 10,
         $sort: {
@@ -79,10 +79,10 @@ if (import.meta.vitest) {
         },
         a: 1,
         b: 2,
-      };
+      }
 
       expect(filterQuery(query)).toEqual({
-        $select: ["a"],
+        $select: ['a'],
         $limit: 10,
         $skip: 10,
         $sort: {
@@ -92,42 +92,42 @@ if (import.meta.vitest) {
           a: 1,
           b: 2,
         },
-      });
-    });
+      })
+    })
 
-    it("should not include filters if not provided", () => {
+    it('should not include filters if not provided', () => {
       const query = {
         a: 1,
         b: 2,
-      };
+      }
 
       expect(filterQuery(query)).toEqual({
         query: {
           a: 1,
           b: 2,
         },
-      });
-    });
+      })
+    })
 
-    it("sets empty query object if empty object is provided", () => {
+    it('sets empty query object if empty object is provided', () => {
       expect(filterQuery({})).toEqual({
         query: {},
-      });
-    });
+      })
+    })
 
-    it("sets empty query object if undefined is provided", () => {
+    it('sets empty query object if undefined is provided', () => {
       expect(filterQuery(undefined)).toEqual({
         query: {},
-      });
-    });
-  });
+      })
+    })
+  })
 
-  describe("reassembleQuery", () => {
-    it("should filter query", () => {
+  describe('reassembleQuery', () => {
+    it('should filter query', () => {
       expect(
         reassembleQuery(
           filterQuery({
-            $select: ["a"],
+            $select: ['a'],
             $limit: 10,
             $skip: 10,
             $sort: {
@@ -138,7 +138,7 @@ if (import.meta.vitest) {
           }),
         ),
       ).toEqual({
-        $select: ["a"],
+        $select: ['a'],
         $limit: 10,
         $skip: 10,
         $sort: {
@@ -146,10 +146,10 @@ if (import.meta.vitest) {
         },
         a: 1,
         b: 2,
-      });
-    });
+      })
+    })
 
-    it("should not include filters if not provided", () => {
+    it('should not include filters if not provided', () => {
       expect(
         reassembleQuery(
           filterQuery({
@@ -160,11 +160,11 @@ if (import.meta.vitest) {
       ).toEqual({
         a: 1,
         b: 2,
-      });
-    });
+      })
+    })
 
-    it("sets empty query object if empty object is provided", () => {
-      expect(reassembleQuery(filterQuery({}))).toEqual({});
-    });
-  });
+    it('sets empty query object if empty object is provided', () => {
+      expect(reassembleQuery(filterQuery({}))).toEqual({})
+    })
+  })
 }

package/src/utils/flattenQuery.ts

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