feathers-utils 6.0.0 → 7.0.1

package/src/utils/markHookForSkip.ts

@@ -1,132 +1,131 @@
-import { pushSet } from "./pushSet";
+import { pushSet } from './pushSet.js'
 
-import type { HookContext } from "@feathersjs/feathers";
-import type { HookType } from "feathers-hooks-common";
-import type { MaybeArray } from "../typesInternal";
+import type { HookContext } from '@feathersjs/feathers'
+import type { HookType } from 'feathers-hooks-common'
+import type { MaybeArray } from '../typesInternal.js'
 
 /**
  * util to mark a hook for skip, has to be used with `shouldSkip`
  */
 export function markHookForSkip<H extends HookContext = HookContext>(
   hookName: string,
-  type: "all" | MaybeArray<HookType>,
+  type: 'all' | MaybeArray<HookType>,
   context?: H,
 ) {
   // @ts-expect-error context is not of type 'H'
-  context = context || {};
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  const params = context!.params || {};
-  const types: string[] = Array.isArray(type) ? type : [type];
+  context = context || {}
+
+  const params = context!.params || {}
+  const types: string[] = Array.isArray(type) ? type : [type]
 
   types.forEach((t) => {
-    const combinedName = t === "all" ? hookName : `${type}:${hookName}`;
-    pushSet(params, ["skipHooks"], combinedName, { unique: true });
-  });
+    const combinedName = t === 'all' ? hookName : `${type}:${hookName}`
+    pushSet(params, ['skipHooks'], combinedName, { unique: true })
+  })
 
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  context!.params = params;
-  return context;
+  context!.params = params
+  return context
 }
 
 if (import.meta.vitest) {
-  const { it, assert } = import.meta.vitest;
-  const { feathers } = await import("@feathersjs/feathers");
-  const { MemoryService } = await import("@feathersjs/memory");
-  const { hasOwnProperty } = await import("./_utils.internal");
-  const { shouldSkip } = await import("./shouldSkip");
+  const { it, assert } = import.meta.vitest
+  const { feathers } = await import('@feathersjs/feathers')
+  const { MemoryService } = await import('@feathersjs/memory')
+  const { hasOwnProperty } = await import('./_utils.internal.js')
+  const { shouldSkip } = await import('./shouldSkip.js')
 
-  it("returns hook object", function () {
-    const context = markHookForSkip("test", "all");
-    assert.ok(context, "returned context");
-    assert.ok(context.params.skipHooks, "has skipHooks");
-  });
+  it('returns hook object', function () {
+    const context = markHookForSkip('test', 'all')
+    assert.ok(context, 'returned context')
+    assert.ok(context?.params.skipHooks, 'has skipHooks')
+  })
 
-  it("returns hook object for undefined context", function () {
-    const context = markHookForSkip("test", "all");
-    assert.ok(context, "returned context");
-    assert.ok(context.params.skipHooks, "has skipHooks");
-  });
+  it('returns hook object for undefined context', function () {
+    const context = markHookForSkip('test', 'all')
+    assert.ok(context, 'returned context')
+    assert.ok(context?.params.skipHooks, 'has skipHooks')
+  })
 
-  it("skips explicitly before hook", async function () {
-    const app = feathers();
-    app.use("service", new MemoryService());
-    const service = app.service("service");
-    const ranInto = {};
+  it('skips explicitly before hook', async function () {
+    const app = feathers()
+    app.use('service', new MemoryService())
+    const service = app.service('service')
+    const ranInto: Record<string, boolean> = {}
     service.hooks({
       before: {
         all: [
           (context) => {
-            markHookForSkip("test", "before", context);
+            markHookForSkip('test', 'before', context)
           },
         ],
         find: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["find"] = true;
+            ranInto['find'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         get: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["get"] = true;
+            ranInto['get'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         create: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["create"] = true;
+            ranInto['create'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         update: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["update"] = true;
+            ranInto['update'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         patch: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["patch"] = true;
+            ranInto['patch'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         remove: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["remove"] = true;
+            ranInto['remove'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
       },
-    });
+    })
     const methods = {
       find: [],
       get: [1],
@@ -134,109 +133,109 @@ if (import.meta.vitest) {
       update: [1, {}],
       patch: [1, {}],
       remove: [1],
-    };
+    }
     const promises = Object.keys(methods).map(async (method) => {
-      await service[method](...methods[method]);
+      await ((service as any)[method] as any)(...(methods as any)[method])
       assert.ok(
         !hasOwnProperty(ranInto, method),
         `'${method}': did not run into hook`,
-      );
-      return true;
-    });
+      )
+      return true
+    })
 
-    const results = await Promise.all(promises);
+    const results = await Promise.all(promises)
     assert.ok(
       results.every((x) => x === true),
-      "all ok",
-    );
-  });
+      'all ok',
+    )
+  })
 
-  it("skips explicitly after hook", async function () {
-    const app = feathers();
-    app.use("service", new MemoryService());
-    const service = app.service("service");
-    const ranInto = {};
+  it('skips explicitly after hook', async function () {
+    const app = feathers()
+    app.use('service', new MemoryService())
+    const service = app.service('service')
+    const ranInto: Record<string, boolean> = {}
     service.hooks({
       before: {
         all: [
           (context) => {
-            markHookForSkip("test", "after", context);
+            markHookForSkip('test', 'after', context)
           },
           (context) => {
-            context.result = null;
-            return context;
+            context.result = null
+            return context
           },
         ],
       },
       after: {
         find: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["find"] = true;
+            ranInto['find'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         get: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["get"] = true;
+            ranInto['get'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         create: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["create"] = true;
+            ranInto['create'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         update: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["update"] = true;
+            ranInto['update'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         patch: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["patch"] = true;
+            ranInto['patch'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         remove: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranInto["remove"] = true;
+            ranInto['remove'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
       },
-    });
+    })
     const methods = {
       find: [],
       get: [1],
@@ -244,172 +243,172 @@ if (import.meta.vitest) {
       update: [1, {}],
       patch: [1, {}],
       remove: [1],
-    };
+    }
     const promises = Object.keys(methods).map(async (method) => {
-      await service[method](...methods[method]);
+      await ((service as any)[method] as any)(...(methods as any)[method])
       assert.ok(
         !hasOwnProperty(ranInto, method),
         `'${method}': did not run into hook`,
-      );
-      return true;
-    });
+      )
+      return true
+    })
 
-    const results = await Promise.all(promises);
+    const results = await Promise.all(promises)
     assert.ok(
       results.every((x) => x === true),
-      "all ok",
-    );
-  });
+      'all ok',
+    )
+  })
 
-  it("skips all hooks", async function () {
-    const app = feathers();
-    app.use("service", new MemoryService());
-    const service = app.service("service");
-    const ranIntoBefore = {};
-    const ranIntoAfter = {};
+  it('skips all hooks', async function () {
+    const app = feathers()
+    app.use('service', new MemoryService())
+    const service = app.service('service')
+    const ranIntoBefore: Record<string, boolean> = {}
+    const ranIntoAfter: Record<string, boolean> = {}
     service.hooks({
       before: {
         all: [
           (context) => {
-            markHookForSkip("test", "all", context);
+            markHookForSkip('test', 'all', context)
           },
         ],
         find: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoBefore["find"] = true;
+            ranIntoBefore['find'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         get: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoBefore["get"] = true;
+            ranIntoBefore['get'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         create: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoBefore["create"] = true;
+            ranIntoBefore['create'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         update: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoBefore["update"] = true;
+            ranIntoBefore['update'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         patch: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoBefore["patch"] = true;
+            ranIntoBefore['patch'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         remove: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoBefore["remove"] = true;
+            ranIntoBefore['remove'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
       },
       after: {
         find: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoAfter["find"] = true;
+            ranIntoAfter['find'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         get: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoAfter["get"] = true;
+            ranIntoAfter['get'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         create: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoAfter["create"] = true;
+            ranIntoAfter['create'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         update: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoAfter["update"] = true;
+            ranIntoAfter['update'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         patch: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoAfter["patch"] = true;
+            ranIntoAfter['patch'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
         remove: [
           (context) => {
-            if (shouldSkip("test", context)) {
-              return context;
+            if (shouldSkip('test', context)) {
+              return context
             }
-            ranIntoAfter["remove"] = true;
+            ranIntoAfter['remove'] = true
           },
           (context) => {
-            context.result = null;
+            context.result = null
           },
         ],
       },
-    });
+    })
     const methods = {
       find: [],
       get: [1],
@@ -417,24 +416,24 @@ if (import.meta.vitest) {
       update: [1, {}],
       patch: [1, {}],
       remove: [1],
-    };
+    }
     const promises = Object.keys(methods).map(async (method) => {
-      await service[method](...methods[method]);
+      await ((service as any)[method] as any)(...(methods as any)[method])
       assert.ok(
         !hasOwnProperty(ranIntoBefore, method),
         `'${method}': did not run into before hook`,
-      );
+      )
       assert.ok(
         !hasOwnProperty(ranIntoAfter, method),
         `'${method}': did not run into after hook`,
-      );
-      return true;
-    });
+      )
+      return true
+    })
 
-    const results = await Promise.all(promises);
+    const results = await Promise.all(promises)
     assert.ok(
       results.every((x) => x === true),
-      "all ok",
-    );
-  });
+      'all ok',
+    )
+  })
 }

package/src/utils/mergeQuery/index.ts

@@ -1,3 +1,3 @@
-export * from "./mergeArrays";
-export * from "./mergeQuery";
-export * from "./types";
+export * from './mergeArrays.js'
+export * from './mergeQuery.js'
+export * from './types.js'