feathers-utils 1.12.0 → 1.13.0

package/dist/esm/hooks/forEach.d.ts

@@ -0,0 +1,8 @@
+import type { ReturnAsyncHook, Promisable } from "../types";
+import type { HookContext } from "@feathersjs/feathers";
+import type { GetItemsIsArrayOptions } from "../utils/getItemsIsArray";
+export interface HookForEachOptions {
+    wait?: "sequential" | "parallel" | false;
+    items?: GetItemsIsArrayOptions["from"];
+}
+export declare const forEach: (actionPerItem: (item: any, context: HookContext) => Promisable<any>, _options?: HookForEachOptions) => ReturnAsyncHook;

package/dist/esm/hooks/forEach.js

@@ -0,0 +1,31 @@
+import { shouldSkip } from "../utils/shouldSkip";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+export const forEach = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+actionPerItem, _options) => {
+    const options = {
+        wait: "parallel",
+        items: "automatic",
+        ..._options
+    };
+    return async (context) => {
+        if (shouldSkip("runForItems", context)) {
+            return context;
+        }
+        const { items } = getItemsIsArray(context, { from: options.items });
+        const promises = [];
+        for (const item of items) {
+            const promise = actionPerItem(item, context);
+            if (options.wait === "sequential") {
+                await promise;
+            }
+            else {
+                promises.push(promise);
+            }
+        }
+        if (options.wait === "parallel") {
+            await Promise.all(promises);
+        }
+        return context;
+    };
+};

package/dist/esm/hooks/parseFields.d.ts

@@ -0,0 +1,8 @@
+import type { HookContext } from "@feathersjs/feathers";
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+export declare const parseFields: (type: "date" | "number", options: {
+    fields: string[];
+}) => (context: HookContext) => HookContext<any, import("@feathersjs/feathers").Service<any>>;

package/dist/esm/hooks/parseFields.js

@@ -0,0 +1,23 @@
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+export const parseFields = (type, options) => (context) => {
+    const { items } = getItemsIsArray(context);
+    items.forEach(item => {
+        options.fields.forEach(field => {
+            // ignore undefined fields
+            if (!(field in item)) {
+                return;
+            }
+            if (type === "date") {
+                item[field] = new Date(item[field]);
+            }
+            else if (type === "number") {
+                item[field] = Number(item[field]);
+            }
+        });
+    });
+    return context;
+};

package/dist/esm/index.d.ts

@@ -11,6 +11,8 @@ export { createRelated } from "./hooks/createRelated";
 export { setData };
 export { removeRelated } from "./hooks/removeRelated";
 export { runPerItem };
+export * from "./hooks/forEach";
+export * from "./hooks/parseFields";
 import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
 export declare const mixins: {
     debounceMixin: typeof debounceMixin;

package/dist/esm/index.js

@@ -12,6 +12,8 @@ export { createRelated } from "./hooks/createRelated";
 export { setData };
 export { removeRelated } from "./hooks/removeRelated";
 export { runPerItem };
+export * from "./hooks/forEach";
+export * from "./hooks/parseFields";
 import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
 export const mixins = {
     debounceMixin,

package/dist/esm/types.d.ts

@@ -82,7 +82,7 @@ export interface FilterQueryResult {
     paginate?: unknown;
     [key: string]: unknown;
 }
-export interface GetItemsIsArrayOptions<T = any> {
+export interface GetItemsIsArrayResult<T = any> {
     items: T[];
     isArray: boolean;
 }

package/dist/esm/utils/getItemsIsArray.d.ts

@@ -1,3 +1,6 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { GetItemsIsArrayOptions } from "..";
-export declare const getItemsIsArray: <T = any>(context: HookContext) => GetItemsIsArrayOptions<T>;
+import type { GetItemsIsArrayResult } from "..";
+export declare type GetItemsIsArrayOptions = {
+    from: "data" | "result" | "automatic";
+};
+export declare const getItemsIsArray: <T = any>(context: HookContext, options?: GetItemsIsArrayOptions) => GetItemsIsArrayResult<T>;

package/dist/esm/utils/getItemsIsArray.js

@@ -1,11 +1,21 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const getItemsIsArray = (context) => {
-    let itemOrItems = context.type === "before"
-        ? context.data
-        : context.result;
-    itemOrItems = itemOrItems && context.method === "find"
-        ? (itemOrItems.data || itemOrItems)
-        : itemOrItems;
+export const getItemsIsArray = (context, options) => {
+    const { from = "automatic" } = options || {};
+    let itemOrItems;
+    if (from === "automatic") {
+        itemOrItems = context.type === "before"
+            ? context.data
+            : context.result;
+        itemOrItems = itemOrItems && context.method === "find"
+            ? (itemOrItems.data || itemOrItems)
+            : itemOrItems;
+    }
+    else if (from === "data") {
+        itemOrItems = context.data;
+    }
+    else if (from === "result") {
+        itemOrItems = context.result;
+    }
     const isArray = Array.isArray(itemOrItems);
     return {
         items: (isArray)

package/dist/hooks/forEach.d.ts

@@ -0,0 +1,8 @@
+import type { ReturnAsyncHook, Promisable } from "../types";
+import type { HookContext } from "@feathersjs/feathers";
+import type { GetItemsIsArrayOptions } from "../utils/getItemsIsArray";
+export interface HookForEachOptions {
+    wait?: "sequential" | "parallel" | false;
+    items?: GetItemsIsArrayOptions["from"];
+}
+export declare const forEach: (actionPerItem: (item: any, context: HookContext) => Promisable<any>, _options?: HookForEachOptions) => ReturnAsyncHook;

package/dist/hooks/forEach.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEach = void 0;
+const shouldSkip_1 = require("../utils/shouldSkip");
+const getItemsIsArray_1 = require("../utils/getItemsIsArray");
+const forEach = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+actionPerItem, _options) => {
+    const options = Object.assign({ wait: "parallel", items: "automatic" }, _options);
+    return (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if ((0, shouldSkip_1.shouldSkip)("runForItems", context)) {
+            return context;
+        }
+        const { items } = (0, getItemsIsArray_1.getItemsIsArray)(context, { from: options.items });
+        const promises = [];
+        for (const item of items) {
+            const promise = actionPerItem(item, context);
+            if (options.wait === "sequential") {
+                yield promise;
+            }
+            else {
+                promises.push(promise);
+            }
+        }
+        if (options.wait === "parallel") {
+            yield Promise.all(promises);
+        }
+        return context;
+    });
+};
+exports.forEach = forEach;

package/dist/hooks/parseFields.d.ts

@@ -0,0 +1,8 @@
+import type { HookContext } from "@feathersjs/feathers";
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+export declare const parseFields: (type: "date" | "number", options: {
+    fields: string[];
+}) => (context: HookContext) => HookContext<any, import("@feathersjs/feathers").Service<any>>;

package/dist/hooks/parseFields.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFields = void 0;
+const getItemsIsArray_1 = require("../utils/getItemsIsArray");
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+const parseFields = (type, options) => (context) => {
+    const { items } = (0, getItemsIsArray_1.getItemsIsArray)(context);
+    items.forEach(item => {
+        options.fields.forEach(field => {
+            // ignore undefined fields
+            if (!(field in item)) {
+                return;
+            }
+            if (type === "date") {
+                item[field] = new Date(item[field]);
+            }
+            else if (type === "number") {
+                item[field] = Number(item[field]);
+            }
+        });
+    });
+    return context;
+};
+exports.parseFields = parseFields;

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export { createRelated } from "./hooks/createRelated";
 export { setData };
 export { removeRelated } from "./hooks/removeRelated";
 export { runPerItem };
+export * from "./hooks/forEach";
+export * from "./hooks/parseFields";
 import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
 export declare const mixins: {
     debounceMixin: typeof debounceMixin;

package/dist/index.js

@@ -31,6 +31,8 @@ var createRelated_1 = require("./hooks/createRelated");
 Object.defineProperty(exports, "createRelated", { enumerable: true, get: function () { return createRelated_1.createRelated; } });
 var removeRelated_1 = require("./hooks/removeRelated");
 Object.defineProperty(exports, "removeRelated", { enumerable: true, get: function () { return removeRelated_1.removeRelated; } });
+__exportStar(require("./hooks/forEach"), exports);
+__exportStar(require("./hooks/parseFields"), exports);
 const debounce_mixin_1 = require("./mixins/debounce-mixin");
 Object.defineProperty(exports, "debounceMixin", { enumerable: true, get: function () { return debounce_mixin_1.debounceMixin; } });
 Object.defineProperty(exports, "DebouncedStore", { enumerable: true, get: function () { return debounce_mixin_1.DebouncedStore; } });

package/dist/types.d.ts

@@ -82,7 +82,7 @@ export interface FilterQueryResult {
     paginate?: unknown;
     [key: string]: unknown;
 }
-export interface GetItemsIsArrayOptions<T = any> {
+export interface GetItemsIsArrayResult<T = any> {
     items: T[];
     isArray: boolean;
 }

package/dist/utils/getItemsIsArray.d.ts

@@ -1,3 +1,6 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { GetItemsIsArrayOptions } from "..";
-export declare const getItemsIsArray: <T = any>(context: HookContext) => GetItemsIsArrayOptions<T>;
+import type { GetItemsIsArrayResult } from "..";
+export declare type GetItemsIsArrayOptions = {
+    from: "data" | "result" | "automatic";
+};
+export declare const getItemsIsArray: <T = any>(context: HookContext, options?: GetItemsIsArrayOptions) => GetItemsIsArrayResult<T>;

package/dist/utils/getItemsIsArray.js

@@ -2,13 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getItemsIsArray = void 0;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const getItemsIsArray = (context) => {
-    let itemOrItems = context.type === "before"
-        ? context.data
-        : context.result;
-    itemOrItems = itemOrItems && context.method === "find"
-        ? (itemOrItems.data || itemOrItems)
-        : itemOrItems;
+const getItemsIsArray = (context, options) => {
+    const { from = "automatic" } = options || {};
+    let itemOrItems;
+    if (from === "automatic") {
+        itemOrItems = context.type === "before"
+            ? context.data
+            : context.result;
+        itemOrItems = itemOrItems && context.method === "find"
+            ? (itemOrItems.data || itemOrItems)
+            : itemOrItems;
+    }
+    else if (from === "data") {
+        itemOrItems = context.data;
+    }
+    else if (from === "result") {
+        itemOrItems = context.result;
+    }
     const isArray = Array.isArray(itemOrItems);
     return {
         items: (isArray)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feathers-utils",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "Some utils for projects using '@feathersjs/feathers'",
   "author": "fratzinger",
   "repository": {

package/src/hooks/forEach.ts

@@ -0,0 +1,47 @@
+import { shouldSkip } from "../utils/shouldSkip";
+
+import type { ReturnAsyncHook, Promisable } from "../types";
+import type { HookContext } from "@feathersjs/feathers";
+import type { GetItemsIsArrayOptions } from "../utils/getItemsIsArray";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+export interface HookForEachOptions {
+  wait?: "sequential" | "parallel" | false
+  items?: GetItemsIsArrayOptions["from"]
+}
+
+export const forEach = (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  actionPerItem: (item: any, context: HookContext) => Promisable<any>, 
+  _options?: HookForEachOptions
+): ReturnAsyncHook => {
+  const options: Required<HookForEachOptions> = {
+    wait: "parallel",
+    items: "automatic",
+    ..._options
+  };
+
+  return async (context: HookContext): Promise<HookContext> => {
+    if (shouldSkip("runForItems", context)) { return context; }
+
+    const { items } =  getItemsIsArray(context, { from: options.items });
+
+    const promises: Promise<any>[] = [];
+
+    for (const item of items) {
+      const promise = actionPerItem(item, context);
+
+      if (options.wait === "sequential") {
+        await promise;
+      } else {
+        promises.push(promise);
+      }
+    }
+
+    if (options.wait === "parallel") {
+      await Promise.all(promises);
+    }
+
+    return context;
+  };
+};

package/src/hooks/parseFields.ts

@@ -0,0 +1,27 @@
+import type { HookContext } from "@feathersjs/feathers";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
+
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+export const parseFields = (type: "date" | "number", options: { fields: string[] }) => (context: HookContext) => {
+  const { items } = getItemsIsArray(context);
+  
+  items.forEach(item => {
+    options.fields.forEach(field => {
+      // ignore undefined fields
+      if (!(field in item)) {
+        return;
+      }
+  
+      if (type === "date") {
+        item[field] = new Date(item[field]);
+      } else if (type === "number") {
+        item[field] = Number(item[field]);
+      }
+    });
+  });
+
+  return context;
+};

package/src/index.ts

@@ -15,6 +15,8 @@ export { createRelated } from "./hooks/createRelated";
 export { setData };
 export { removeRelated } from "./hooks/removeRelated";
 export { runPerItem };
+export * from "./hooks/forEach";
+export * from "./hooks/parseFields";
 
 import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
 

package/src/types.ts

@@ -120,7 +120,7 @@ export interface FilterQueryResult {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface GetItemsIsArrayOptions<T = any> {
+export interface GetItemsIsArrayResult<T = any> {
   items: T[]
   isArray: boolean
 }

package/src/utils/getItemsIsArray.ts

@@ -1,16 +1,34 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { GetItemsIsArrayOptions } from "..";
+import type { GetItemsIsArrayResult } from "..";
+
+export type GetItemsIsArrayOptions = {
+  from: "data" | "result" | "automatic"
+}
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const getItemsIsArray = <T = any>(
-  context: HookContext
-): GetItemsIsArrayOptions<T> => {
-  let itemOrItems = context.type === "before" 
-    ? context.data 
-    : context.result;
-  itemOrItems = itemOrItems && context.method === "find" 
-    ? (itemOrItems.data || itemOrItems) 
-    : itemOrItems;
+  context: HookContext,
+  options?: GetItemsIsArrayOptions
+): GetItemsIsArrayResult<T> => {
+  const {
+    from = "automatic"
+  } = options || {};
+
+  let itemOrItems;
+
+  if (from === "automatic") {
+    itemOrItems = context.type === "before" 
+      ? context.data 
+      : context.result;
+    itemOrItems = itemOrItems && context.method === "find" 
+      ? (itemOrItems.data || itemOrItems) 
+      : itemOrItems;
+  } else if (from === "data") {
+    itemOrItems = context.data;
+  } else if (from === "result") {
+    itemOrItems = context.result;
+  }
+  
   const isArray = Array.isArray(itemOrItems);
   return {
     items: (isArray)