feathers-utils 5.1.0 → 6.0.0

package/src/utils/shouldSkip.ts

@@ -38,3 +38,124 @@ export const shouldSkip = <H extends HookContext = HookContext>(
 
   return false;
 };
+
+if (import.meta.vitest) {
+  const { it, assert } = import.meta.vitest;
+
+  it("returns false if skipHooks not defined", function () {
+    ["before", "after"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = { type, method } as HookContext;
+          assert.strictEqual(
+            shouldSkip("all", context),
+            false,
+            `'${type}:${method}': returns false`,
+          );
+        },
+      );
+    });
+  });
+
+  it("returns true for skipHooks: ['all']", function () {
+    ["before", "after", "error"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = {
+            type,
+            method,
+            params: { skipHooks: ["all"] },
+          } as HookContext;
+          assert.strictEqual(
+            shouldSkip("test", context),
+            true,
+            `'${type}:${method}': returns true`,
+          );
+        },
+      );
+    });
+  });
+
+  it("returns true for skipHooks: [`type`]", function () {
+    ["before", "after", "error"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = {
+            type,
+            method,
+            params: { skipHooks: [type] },
+          } as HookContext;
+          assert.strictEqual(
+            shouldSkip("test", context),
+            true,
+            `'${type}:${method}': returns true`,
+          );
+        },
+      );
+    });
+  });
+
+  it("returns true for skipHooks: ['`type`:test']", function () {
+    ["before", "after", "error"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = {
+            type,
+            method,
+            params: { skipHooks: [`${type}:test`] },
+          } as HookContext;
+          assert.strictEqual(
+            shouldSkip("test", context),
+            true,
+            `'${type}:${method}': returns true`,
+          );
+        },
+      );
+    });
+  });
+
+  it("returns true for skipHooks: ['test']", function () {
+    ["before", "after", "error"].forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const context = {
+            type,
+            method,
+            params: { skipHooks: ["test"] },
+          } as HookContext;
+          assert.strictEqual(
+            shouldSkip("test", context),
+            true,
+            `'${type}:${method}': returns true`,
+          );
+        },
+      );
+    });
+  });
+
+  it("returns false for skipHooks other than test", function () {
+    const types = ["before", "after", "error"];
+    types.forEach((type) => {
+      ["find", "get", "create", "update", "patch", "remove"].forEach(
+        (method) => {
+          const remainingTypes = types.filter((x) => x !== type);
+          const skipHooks = [
+            "test2",
+            `${type}:test2`,
+            ...remainingTypes.map((t) => `${t}:test1`),
+          ];
+          const context = {
+            type,
+            method,
+            params: { skipHooks },
+          } as HookContext;
+          assert.strictEqual(
+            shouldSkip("test1", context),
+            false,
+            `'${type}:${method}': returns true`,
+          );
+        },
+      );
+    });
+  });
+}

package/src/utils/validateQueryProperty.ts

@@ -1,9 +1,6 @@
-import { _ } from "@feathersjs/commons";
 import { BadRequest } from "@feathersjs/errors";
 import type { Query } from "@feathersjs/feathers";
-
-const isPlainObject = (value: any) =>
-  _.isObject(value) && value.constructor === {}.constructor;
+import { isObject } from "./_utils.internal";
 
 /**
  * util to validate a query for operators
@@ -12,7 +9,7 @@ export const validateQueryProperty = (
   query: any,
   operators: string[] = [],
 ): Query => {
-  if (!isPlainObject(query)) {
+  if (!isObject(query)) {
     return query;
   }
 
@@ -23,7 +20,7 @@ export const validateQueryProperty = (
 
     const value = query[key];
 
-    if (isPlainObject(value)) {
+    if (isObject(value)) {
       query[key] = validateQueryProperty(value, operators);
     }
   }

package/src/utils/internal.utils.ts

@@ -1,9 +0,0 @@
-export const hasOwnProperty = (
-  obj: Record<string, unknown>,
-  ...keys: string[]
-): boolean => {
-  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
-};
-
-export const isPlainObject = (value) =>
-  value && [undefined, Object].includes(value.constructor);