feathers-utils 6.0.0 → 7.0.1

package/src/utils/setResultEmpty.ts

@@ -1,6 +1,6 @@
-import type { HookContext } from "@feathersjs/feathers";
-import { isMulti } from "./isMulti";
-import { isPaginated } from "./isPaginated";
+import type { HookContext } from '@feathersjs/feathers'
+import { isMulti } from './isMulti.js'
+import { isPaginated } from './isPaginated.js'
 
 /**
  * util to set `context.result` to an empty array or object, depending on the hook type
@@ -9,31 +9,31 @@ export const setResultEmpty = <H extends HookContext = HookContext>(
   context: H,
 ) => {
   if (context.result) {
-    return context;
+    return context
   }
 
-  const multi = isMulti(context);
+  const multi = isMulti(context)
 
   if (multi) {
-    if (context.method === "find" && isPaginated(context)) {
+    if (context.method === 'find' && isPaginated(context)) {
       context.result = {
         total: 0,
         skip: 0,
         limit: 0,
         data: [],
-      };
+      }
     } else {
-      context.result = [];
+      context.result = []
     }
   } else {
-    context.result = null;
+    context.result = null
   }
 
-  return context;
-};
+  return context
+}
 
 if (import.meta.vitest) {
-  const { it, assert } = import.meta.vitest;
+  const { it, assert } = import.meta.vitest
 
   const paginatedService = {
     options: {
@@ -42,252 +42,254 @@ if (import.meta.vitest) {
         max: 50,
       },
     },
-  };
+  }
 
   const nonPaginatedService = {
     options: {
       paginate: false,
     },
-  };
+  }
 
-  const paramsEmpty = {};
-  const paramsPaginateFalse = { paginate: false };
-  const paramsPaginate = { paginate: { default: 10, max: 50 } };
+  const paramsEmpty = {}
+  const paramsPaginateFalse = { paginate: false }
+  const paramsPaginate = { paginate: { default: 10, max: 50 } }
   const paramsAdapterPaginate = {
     adapter: { paginate: { default: 10, max: 50 } },
-  };
+  }
 
-  it("does not overwrite result", function () {
-    ["find", "get", "create", "update", "patch", "remove"].forEach((method) => {
-      ["before", "after"].forEach((type) => {
-        [paginatedService, nonPaginatedService].forEach((service) => {
-          [paramsPaginateFalse, paramsAdapterPaginate].forEach((params) => {
-            const context = setResultEmpty({
-              method,
-              type,
-              service,
-              params,
-              result: 123,
-            } as any as HookContext);
+  it('does not overwrite result', function () {
+    ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
+      (method) => {
+        ;['before', 'after'].forEach((type) => {
+          ;[paginatedService, nonPaginatedService].forEach((service) => {
+            ;[paramsPaginateFalse, paramsAdapterPaginate].forEach((params) => {
+              const context = setResultEmpty({
+                method,
+                type,
+                service,
+                params,
+                result: 123,
+              } as any as HookContext)
 
-            assert.deepStrictEqual(
-              context.result,
-              123,
-              `result is not changed. '${type}:${method}': '${service}' - '${params}'`,
-            );
-          });
-        });
-      });
-    });
-  });
+              assert.deepStrictEqual(
+                context.result,
+                123,
+                `result is not changed. '${type}:${method}': '${service}' - '${params}'`,
+              )
+            })
+          })
+        })
+      },
+    )
+  })
 
-  describe("find", function () {
-    it("sets paginated result", function () {
+  describe('find', function () {
+    it('sets paginated result', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "find",
-        } as any as HookContext);
+          method: 'find',
+        } as any as HookContext)
         assert.deepStrictEqual(
           result,
           { total: 0, skip: 0, limit: 0, data: [] },
           `'${i}': result is paginated empty`,
-        );
-      });
-    });
+        )
+      })
+    })
 
-    it("sets empty array", function () {
+    it('sets empty array', function () {
       const combos = [
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsEmpty },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "find",
-        } as any as HookContext);
-        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
-      });
-    });
-  });
+          method: 'find',
+        } as any as HookContext)
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`)
+      })
+    })
+  })
 
-  describe("get", function () {
-    it("sets result to null", function () {
+  describe('get', function () {
+    it('sets result to null', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "get",
-        } as any as HookContext);
-        assert.deepStrictEqual(result, null, `'${i}': result is null`);
-      });
-    });
-  });
+          method: 'get',
+        } as any as HookContext)
+        assert.deepStrictEqual(result, null, `'${i}': result is null`)
+      })
+    })
+  })
 
-  describe("create", function () {
-    it("sets result to null for single data", function () {
+  describe('create', function () {
+    it('sets result to null for single data', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "create",
+          method: 'create',
           data: { id: 1 },
-        } as any as HookContext);
-        assert.deepStrictEqual(result, null, `'${i}': result is null`);
-      });
-    });
+        } as any as HookContext)
+        assert.deepStrictEqual(result, null, `'${i}': result is null`)
+      })
+    })
 
-    it("sets result to empty array for array data", function () {
+    it('sets result to empty array for array data', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "create",
+          method: 'create',
           data: [{ id: 1 }],
-          type: "before",
-        } as any as HookContext);
-        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
-      });
-    });
-  });
+          type: 'before',
+        } as any as HookContext)
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`)
+      })
+    })
+  })
 
-  describe("update", function () {
-    it("sets result to null", function () {
+  describe('update', function () {
+    it('sets result to null', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "update",
+          method: 'update',
           id: 1,
-        } as any as HookContext);
-        assert.deepStrictEqual(result, null, `'${i}': result is null`);
-      });
-    });
-  });
+        } as any as HookContext)
+        assert.deepStrictEqual(result, null, `'${i}': result is null`)
+      })
+    })
+  })
 
-  describe("patch", function () {
-    it("sets result to null for id: 1", function () {
+  describe('patch', function () {
+    it('sets result to null for id: 1', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "patch",
+          method: 'patch',
           id: 1,
-        } as any as HookContext);
-        assert.deepStrictEqual(result, null, `'${i}': result is null`);
-      });
-    });
+        } as any as HookContext)
+        assert.deepStrictEqual(result, null, `'${i}': result is null`)
+      })
+    })
 
-    it("sets result to empty array for id: null", function () {
+    it('sets result to empty array for id: null', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "patch",
+          method: 'patch',
           id: null,
-        } as any as HookContext);
-        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
-      });
-    });
-  });
+        } as any as HookContext)
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`)
+      })
+    })
+  })
 
-  describe("remove", function () {
-    it("sets result to null for id: 1", function () {
+  describe('remove', function () {
+    it('sets result to null for id: 1', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "remove",
+          method: 'remove',
           id: 1,
-        } as any as HookContext);
-        assert.deepStrictEqual(result, null, `'${i}': result is null`);
-      });
-    });
+        } as any as HookContext)
+        assert.deepStrictEqual(result, null, `'${i}': result is null`)
+      })
+    })
 
-    it("sets result to empty array for id: null", function () {
+    it('sets result to empty array for id: null', function () {
       const combos = [
         { service: paginatedService, params: paramsEmpty },
         { service: paginatedService, params: paramsAdapterPaginate },
         { service: paginatedService, params: paramsPaginateFalse },
         { service: nonPaginatedService, params: paramsPaginate },
         { service: nonPaginatedService, params: paramsAdapterPaginate },
-      ];
+      ]
 
       combos.forEach(({ service, params }, i) => {
         const { result } = setResultEmpty({
           service,
           params,
-          method: "remove",
+          method: 'remove',
           id: null,
-        } as any as HookContext);
-        assert.deepStrictEqual(result, [], `'${i}': result is empty array`);
-      });
-    });
-  });
+        } as any as HookContext)
+        assert.deepStrictEqual(result, [], `'${i}': result is empty array`)
+      })
+    })
+  })
 }

package/src/utils/shouldSkip.ts

@@ -1,13 +1,13 @@
 // Kudos to @DaddyWarbucks! This is a cheeky copy of his awesome library: 'feathers-fletching'.
 // Definitely check it out! https://daddywarbucks.github.io/feathers-fletching/overview.html
 
-import { GeneralError } from "@feathersjs/errors";
+import { GeneralError } from '@feathersjs/errors'
 
-import type { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from '@feathersjs/feathers'
 
 export type ShouldSkipOptions = {
-  notSkippable?: boolean;
-};
+  notSkippable?: boolean
+}
 
 /**
  * util to detect if a hook should be skipped
@@ -18,144 +18,144 @@ export const shouldSkip = <H extends HookContext = HookContext>(
   options?: ShouldSkipOptions,
 ): boolean => {
   if (!context.params || !context.params.skipHooks || options?.notSkippable) {
-    return false;
+    return false
   }
 
-  const { skipHooks } = context.params;
+  const { skipHooks } = context.params
   if (!Array.isArray(skipHooks)) {
-    throw new GeneralError("The `skipHooks` param must be an Array of Strings");
+    throw new GeneralError('The `skipHooks` param must be an Array of Strings')
   }
-  const { type } = context;
+  const { type } = context
   if (skipHooks.includes(hookName)) {
-    return true;
-  } else if (skipHooks.includes("all")) {
-    return true;
+    return true
+  } else if (skipHooks.includes('all')) {
+    return true
   } else if (skipHooks.includes(type)) {
-    return true;
+    return true
   } else if (skipHooks.includes(`${type}:${hookName}`)) {
-    return true;
+    return true
   }
 
-  return false;
-};
+  return false
+}
 
 if (import.meta.vitest) {
-  const { it, assert } = 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(
+  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;
+          const context = { type, method } as HookContext
           assert.strictEqual(
-            shouldSkip("all", context),
+            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(
+    ;['before', 'after', 'error'].forEach((type) => {
+      ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
         (method) => {
           const context = {
             type,
             method,
-            params: { skipHooks: ["all"] },
-          } as HookContext;
+            params: { skipHooks: ['all'] },
+          } as HookContext
           assert.strictEqual(
-            shouldSkip("test", context),
+            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(
+  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;
+          } as HookContext
           assert.strictEqual(
-            shouldSkip("test", context),
+            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(
+    ;['before', 'after', 'error'].forEach((type) => {
+      ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
         (method) => {
           const context = {
             type,
             method,
             params: { skipHooks: [`${type}:test`] },
-          } as HookContext;
+          } as HookContext
           assert.strictEqual(
-            shouldSkip("test", context),
+            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(
+    ;['before', 'after', 'error'].forEach((type) => {
+      ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
         (method) => {
           const context = {
             type,
             method,
-            params: { skipHooks: ["test"] },
-          } as HookContext;
+            params: { skipHooks: ['test'] },
+          } as HookContext
           assert.strictEqual(
-            shouldSkip("test", context),
+            shouldSkip('test', context),
             true,
             `'${type}:${method}': returns true`,
-          );
+          )
         },
-      );
-    });
-  });
+      )
+    })
+  })
 
-  it("returns false for skipHooks other than test", function () {
-    const types = ["before", "after", "error"];
+  it('returns false for skipHooks other than test', function () {
+    const types = ['before', 'after', 'error']
     types.forEach((type) => {
-      ["find", "get", "create", "update", "patch", "remove"].forEach(
+      ;['find', 'get', 'create', 'update', 'patch', 'remove'].forEach(
         (method) => {
-          const remainingTypes = types.filter((x) => x !== type);
+          const remainingTypes = types.filter((x) => x !== type)
           const skipHooks = [
-            "test2",
+            'test2',
             `${type}:test2`,
             ...remainingTypes.map((t) => `${t}:test1`),
-          ];
+          ]
           const context = {
             type,
             method,
             params: { skipHooks },
-          } as HookContext;
+          } as HookContext
           assert.strictEqual(
-            shouldSkip("test1", context),
+            shouldSkip('test1', context),
             false,
             `'${type}:${method}': returns true`,
-          );
+          )
         },
-      );
-    });
-  });
+      )
+    })
+  })
 }

package/src/utils/toJSON.ts

@@ -1,8 +1,8 @@
-import type { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from '@feathersjs/feathers'
 
 export const toJSON = (context: HookContext) => {
   if (context.toJSON) {
-    return context.toJSON();
+    return context.toJSON()
   }
-  return context;
-};
+  return context
+}