feathers-utils 6.0.0 → 7.0.1

package/src/utils/getItemsIsArray.ts

@@ -1,208 +1,207 @@
-import type { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from '@feathersjs/feathers'
 
-export type GetItemsIsArrayFrom = "data" | "result" | "automatic";
+export type GetItemsIsArrayFrom = 'data' | 'result' | 'automatic'
 
 export type GetItemsIsArrayOptions = {
-  from?: GetItemsIsArrayFrom;
-};
+  from?: GetItemsIsArrayFrom
+}
 
 export interface GetItemsIsArrayResult<T = any> {
-  items: T[];
-  isArray: boolean;
+  items: T[]
+  isArray: boolean
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const getItemsIsArray = <T = any, H extends HookContext = HookContext>(
   context: H,
   options?: GetItemsIsArrayOptions,
 ): GetItemsIsArrayResult<T> => {
-  const { from = "automatic" } = options || {};
+  const { from = 'automatic' } = options || {}
 
-  let itemOrItems;
+  let itemOrItems
 
-  if (from === "automatic") {
-    itemOrItems = context.type === "before" ? context.data : context.result;
-  } else if (from === "data") {
-    itemOrItems = context.data;
-  } else if (from === "result") {
-    itemOrItems = context.result;
+  if (from === 'automatic') {
+    itemOrItems = context.type === 'before' ? context.data : context.result
+  } else if (from === 'data') {
+    itemOrItems = context.data
+  } else if (from === 'result') {
+    itemOrItems = context.result
   }
 
-  if ((from === "automatic" || from === "result") && context.type === "after") {
+  if ((from === 'automatic' || from === 'result') && context.type === 'after') {
     itemOrItems =
-      itemOrItems && context.method === "find"
+      itemOrItems && context.method === 'find'
         ? itemOrItems.data || itemOrItems
-        : itemOrItems;
+        : itemOrItems
   }
 
-  const isArray = Array.isArray(itemOrItems);
+  const isArray = Array.isArray(itemOrItems)
   return {
     items: isArray ? itemOrItems : itemOrItems != null ? [itemOrItems] : [],
     isArray,
-  };
-};
+  }
+}
 
 if (import.meta.vitest) {
-  const { describe, it, assert } = import.meta.vitest;
+  const { describe, it, assert } = import.meta.vitest
 
-  const assertBefore = (context, items, isArray) => {
+  const assertBefore = (context: any, items: any, isArray: any) => {
     const arrays: (GetItemsIsArrayFrom | undefined)[] = [
       undefined,
-      "data",
-      "automatic",
-    ];
+      '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}`);
+      })
+      assert.deepStrictEqual(items2, items, `from: ${from}`)
+      assert.deepStrictEqual(isArray2, isArray, `from: ${from}`)
     }
-  };
+  }
 
-  const assertAfter = (context, items, isArray) => {
+  const assertAfter = (context: any, items: any, isArray: any) => {
     const arrays: (GetItemsIsArrayFrom | undefined)[] = [
       undefined,
-      "result",
-      "automatic",
-    ];
+      '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}`);
+      })
+      assert.deepStrictEqual(items2, items, `from: ${from}`)
+      assert.deepStrictEqual(isArray2, isArray, `from: ${from}`)
     }
-  };
+  }
 
-  describe("before", function () {
-    it("find:before", async function () {
+  describe('before', function () {
+    it('find:before', async function () {
       const context = {
-        type: "before",
-        method: "find",
+        type: 'before',
+        method: 'find',
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [], false);
-    });
+      assertBefore(context, [], false)
+    })
 
-    it("get:before", async function () {
+    it('get:before', async function () {
       const context = {
-        type: "before",
-        method: "get",
+        type: 'before',
+        method: 'get',
         id: 1,
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [], false);
-    });
+      assertBefore(context, [], false)
+    })
 
-    it("create:before single", async function () {
+    it('create:before single', async function () {
       const context = {
-        type: "before",
-        method: "create",
+        type: 'before',
+        method: 'create',
         data: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [{ test: true }], false);
-    });
+      assertBefore(context, [{ test: true }], false)
+    })
 
-    it("create:before multi", async function () {
+    it('create:before multi', async function () {
       const context = {
-        type: "before",
-        method: "create",
+        type: 'before',
+        method: 'create',
         data: [{ test: true }, { test: true }],
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [{ test: true }, { test: true }], true);
-    });
+      assertBefore(context, [{ test: true }, { test: true }], true)
+    })
 
-    it("update:before single", async function () {
+    it('update:before single', async function () {
       const context = {
-        type: "before",
-        method: "update",
+        type: 'before',
+        method: 'update',
         id: 1,
         data: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [{ test: true }], false);
-    });
+      assertBefore(context, [{ test: true }], false)
+    })
 
-    it("patch:before single", async function () {
+    it('patch:before single', async function () {
       const context = {
-        type: "before",
-        method: "patch",
+        type: 'before',
+        method: 'patch',
         id: 1,
         data: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [{ test: true }], false);
-    });
+      assertBefore(context, [{ test: true }], false)
+    })
 
-    it("patch:before multi", async function () {
+    it('patch:before multi', async function () {
       const context = {
-        type: "before",
-        method: "patch",
+        type: 'before',
+        method: 'patch',
         id: null,
         data: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [{ test: true }], false);
-    });
+      assertBefore(context, [{ test: true }], false)
+    })
 
-    it("remove:before single", async function () {
+    it('remove:before single', async function () {
       const context = {
-        type: "before",
-        method: "remove",
+        type: 'before',
+        method: 'remove',
         id: 1,
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [], false);
-    });
+      assertBefore(context, [], false)
+    })
 
-    it("remove:before multi", async function () {
+    it('remove:before multi', async function () {
       const context = {
-        type: "before",
-        method: "remove",
+        type: 'before',
+        method: 'remove',
         id: null,
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertBefore(context, [], false);
-    });
-  });
+      assertBefore(context, [], false)
+    })
+  })
 
-  describe("after", function () {
-    it("find:after paginate:true", function () {
+  describe('after', function () {
+    it('find:after paginate:true', function () {
       const context = {
-        type: "after",
-        method: "find",
+        type: 'after',
+        method: 'find',
         result: {
           total: 1,
           skip: 0,
@@ -212,111 +211,111 @@ if (import.meta.vitest) {
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }], true);
-    });
+      assertAfter(context, [{ test: true }], true)
+    })
 
-    it("find:after paginate:false", function () {
+    it('find:after paginate:false', function () {
       const context = {
-        type: "after",
-        method: "find",
+        type: 'after',
+        method: 'find',
         result: [{ test: true }],
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }], true);
-    });
+      assertAfter(context, [{ test: true }], true)
+    })
 
-    it("get:after", function () {
+    it('get:after', function () {
       const context = {
-        type: "after",
-        method: "get",
+        type: 'after',
+        method: 'get',
         id: 1,
         result: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }], false);
-    });
+      assertAfter(context, [{ test: true }], false)
+    })
 
-    it("update:after", function () {
+    it('update:after', function () {
       const context = {
-        type: "after",
-        method: "update",
+        type: 'after',
+        method: 'update',
         id: 1,
-        data: { test: "yes" },
+        data: { test: 'yes' },
         result: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }], false);
-    });
+      assertAfter(context, [{ test: true }], false)
+    })
 
-    it("patch:after single", function () {
+    it('patch:after single', function () {
       const context = {
-        type: "after",
-        method: "patch",
+        type: 'after',
+        method: 'patch',
         id: 1,
-        data: { test: "yes" },
+        data: { test: 'yes' },
         result: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }], false);
-    });
+      assertAfter(context, [{ test: true }], false)
+    })
 
-    it("patch:after multi", function () {
+    it('patch:after multi', function () {
       const context = {
-        type: "after",
-        method: "patch",
+        type: 'after',
+        method: 'patch',
         id: null,
-        data: { test: "yes" },
+        data: { test: 'yes' },
         result: [{ test: true }, { test: true }],
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }, { test: true }], true);
-    });
+      assertAfter(context, [{ test: true }, { test: true }], true)
+    })
 
-    it("remove:after single", function () {
+    it('remove:after single', function () {
       const context = {
-        type: "after",
-        method: "remove",
+        type: 'after',
+        method: 'remove',
         id: 1,
-        data: { test: "yes" },
+        data: { test: 'yes' },
         result: { test: true },
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }], false);
-    });
+      assertAfter(context, [{ test: true }], false)
+    })
 
-    it("remove:after multi", function () {
+    it('remove:after multi', function () {
       const context = {
-        type: "after",
-        method: "remove",
+        type: 'after',
+        method: 'remove',
         id: null,
-        data: { test: "yes" },
+        data: { test: 'yes' },
         result: [{ test: true }, { test: true }],
         params: {
           query: {},
         },
-      } as any as HookContext;
+      } as any as HookContext
 
-      assertAfter(context, [{ test: true }, { test: true }], true);
-    });
-  });
+      assertAfter(context, [{ test: true }, { test: true }], true)
+    })
+  })
 }

package/src/utils/getPaginate.ts

@@ -1,6 +1,6 @@
-import type { PaginationOptions } from "@feathersjs/adapter-commons";
-import type { HookContext } from "@feathersjs/feathers";
-import { hasOwnProperty } from "./_utils.internal";
+import type { PaginationOptions } from '@feathersjs/adapter-commons'
+import type { HookContext } from '@feathersjs/feathers'
+import { hasOwnProperty } from './_utils.internal.js'
 
 /**
  * util to get paginate options from context
@@ -11,92 +11,92 @@ import { hasOwnProperty } from "./_utils.internal";
 export const getPaginate = <H extends HookContext = HookContext>(
   context: H,
 ): PaginationOptions | undefined => {
-  if (hasOwnProperty(context.params, "paginate")) {
-    return (context.params.paginate as PaginationOptions) || undefined;
+  if (hasOwnProperty(context.params, 'paginate')) {
+    return (context.params.paginate as PaginationOptions) || undefined
   }
 
   if (context.params.paginate === false) {
-    return undefined;
+    return undefined
   }
-  let options = context.service?.options || {};
+  let options = context.service?.options || {}
 
   options = {
     ...options,
     ...context.params.adapter,
-  };
+  }
 
-  return options.paginate || undefined;
-};
+  return options.paginate || undefined
+}
 
 if (import.meta.vitest) {
-  const { it, assert } = import.meta.vitest;
+  const { it, assert } = import.meta.vitest
 
-  it("returns service.options.paginate", function () {
+  it('returns service.options.paginate', function () {
     const serviceOptions = {
       paginate: {
         default: 10,
         max: 50,
       },
-    };
+    }
 
     const paginate = getPaginate({
       params: {},
       service: {
         options: serviceOptions,
       },
-    } as HookContext);
+    } as HookContext)
 
-    assert.deepStrictEqual(paginate, { default: 10, max: 50 });
-  });
+    assert.deepStrictEqual(paginate, { default: 10, max: 50 })
+  })
 
-  it("returns undefined for params.paginate: false", function () {
+  it('returns undefined for params.paginate: false', function () {
     const serviceOptions = {
       paginate: {
         default: 10,
         max: 50,
       },
-    };
+    }
 
     const paginate = getPaginate({
       params: { paginate: false },
       service: {
         options: serviceOptions,
       },
-    } as HookContext);
+    } as HookContext)
 
-    assert.deepStrictEqual(paginate, undefined);
-  });
+    assert.deepStrictEqual(paginate, undefined)
+  })
 
-  it("returns context.adapter.paginate over service.options.paginate", function () {
+  it('returns context.adapter.paginate over service.options.paginate', function () {
     const serviceOptions = {
       paginate: {
         default: 10,
         max: 50,
       },
-    };
+    }
 
     const paginate = getPaginate({
       params: { adapter: { paginate: { default: 20, max: 100 } } },
       service: {
         options: serviceOptions,
       },
-    } as HookContext);
+    } as HookContext)
 
-    assert.deepStrictEqual(paginate, { default: 20, max: 100 });
-  });
+    assert.deepStrictEqual(paginate, { default: 20, max: 100 })
+  })
 
-  it("returns undefined for no paginate", function () {
+  it('returns undefined for no paginate', function () {
     const serviceOptions = {
       paginate: false,
-    };
+    }
 
     const paginate = getPaginate({
       params: {},
       service: {
         options: serviceOptions,
       },
-    } as HookContext);
+    } as HookContext)
 
-    assert.deepStrictEqual(paginate, undefined);
-  });
+    assert.deepStrictEqual(paginate, undefined)
+  })
 }

package/src/utils/index.ts

@@ -1,17 +1,17 @@
-export * from "./defineHooks";
-export * from "./filterQuery";
-export * from "./getItemsIsArray";
-export * from "./getPaginate";
-export * from "./isMulti";
-export * from "./isPaginated";
-export * from "./markHookForSkip";
-export * from "./mergeQuery";
-export * from "./pushSet";
-export * from "./setQueryKeySafely";
-export * from "./setResultEmpty";
-export * from "./shouldSkip";
-export * from "./toJSON";
-export * from "./validateQueryProperty";
-export * from "./optimizeBatchPatch";
-export * from "./flattenQuery";
-export * from "./deflattenQuery";
+export * from './defineHooks.js'
+export * from './filterQuery.js'
+export * from './getItemsIsArray.js'
+export * from './getPaginate.js'
+export * from './isMulti.js'
+export * from './isPaginated.js'
+export * from './markHookForSkip.js'
+export * from './mergeQuery/index.js'
+export * from './pushSet.js'
+export * from './setQueryKeySafely.js'
+export * from './setResultEmpty.js'
+export * from './shouldSkip.js'
+export * from './toJSON.js'
+export * from './validateQueryProperty.js'
+export * from './optimizeBatchPatch.js'
+export * from './flattenQuery.js'
+export * from './deflattenQuery.js'