feathers-utils 1.6.0 → 1.7.2

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

@@ -0,0 +1,2 @@
+import type { HookContext } from "@feathersjs/feathers";
+export declare function checkMulti(): ((context: HookContext) => HookContext);

package/dist/esm/hooks/checkMulti.js

@@ -0,0 +1,18 @@
+import { MethodNotAllowed } from "@feathersjs/errors";
+import { shouldSkip } from "../utils/shouldSkip";
+import { isMulti } from "../utils/isMulti";
+export function checkMulti() {
+    return (context) => {
+        if (shouldSkip("checkMulti", context)) {
+            return context;
+        }
+        const { service, method } = context;
+        if (!service.allowsMulti || !isMulti(context) || method === "find") {
+            return context;
+        }
+        if (!service.allowsMulti(method)) {
+            throw new MethodNotAllowed(`Can not ${method} multiple entries`);
+        }
+        return context;
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { HookRunPerItemOptions } from "../types";
+import type { HookContext } from "@feathersjs/feathers";
+import type { Promisable } from "type-fest";
+export declare const runPerItem: (actionPerItem: (item: any, context: HookContext) => Promisable<any>, options: HookRunPerItemOptions) => (context: HookContext) => Promise<HookContext>;

package/dist/esm/hooks/runPerItem.js

@@ -0,0 +1,25 @@
+import { getItems } from "feathers-hooks-common";
+import { shouldSkip } from "../utils/shouldSkip";
+const makeOptions = (options) => {
+    options = options || {};
+    return Object.assign({
+        wait: true
+    }, options);
+};
+export const runPerItem = (actionPerItem, options) => {
+    options = makeOptions(options);
+    return async (context) => {
+        if (shouldSkip("runForItems", context)) {
+            return context;
+        }
+        let items = getItems(context);
+        items = (Array.isArray(items)) ? items : [items];
+        const promises = items.map(async (item) => {
+            await actionPerItem(item, context);
+        });
+        if (options.wait) {
+            await Promise.all(promises);
+        }
+        return context;
+    };
+};

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

@@ -0,0 +1,4 @@
+import type { HookContext } from "@feathersjs/feathers";
+import type { HookSetDataOptions } from "../types";
+import type { PropertyPath } from "lodash";
+export declare function setData(from: PropertyPath, to: PropertyPath, _options?: HookSetDataOptions): ((context: HookContext) => HookContext);

package/dist/esm/hooks/setData.js

@@ -0,0 +1,33 @@
+import _get from "lodash/get";
+import _set from "lodash/set";
+import _has from "lodash/has";
+import { getItems } from "feathers-hooks-common";
+import { Forbidden } from "@feathersjs/errors";
+const defaultOptions = {
+    allowUndefined: false,
+    overwrite: true
+};
+export function setData(from, to, _options) {
+    const options = Object.assign({}, defaultOptions, _options);
+    return (context) => {
+        let items = getItems(context);
+        items = (Array.isArray(items)) ? items : [items];
+        if (!_has(context, from)) {
+            if (!context.params?.provider || options.allowUndefined === true) {
+                return context;
+            }
+            if (!options.overwrite && items.every((item) => _has(item, to))) {
+                return context;
+            }
+            throw new Forbidden(`Expected field ${from.toString()} not available`);
+        }
+        const val = _get(context, from);
+        items.forEach((item) => {
+            if (!options.overwrite && _has(item, to)) {
+                return;
+            }
+            _set(item, to, val);
+        });
+        return context;
+    };
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,30 @@
+import { checkMulti } from "./hooks/checkMulti";
+import { setData } from "./hooks/setData";
+import { runPerItem } from "./hooks/runPerItem";
+export declare const hooks: {
+    checkMulti: typeof checkMulti;
+    setData: typeof setData;
+    runPerItem: (actionPerItem: (item: any, context: import("@feathersjs/feathers").HookContext<any, import("@feathersjs/feathers").Service<any>>) => any, options: import("./types").HookRunPerItemOptions) => (context: import("@feathersjs/feathers").HookContext<any, import("@feathersjs/feathers").Service<any>>) => Promise<import("@feathersjs/feathers").HookContext<any, import("@feathersjs/feathers").Service<any>>>;
+};
+export { checkMulti };
+export { setData };
+export { runPerItem };
+import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
+export declare const mixins: {
+    debounceMixin: typeof debounceMixin;
+    DebouncedStore: typeof DebouncedStore;
+};
+export { debounceMixin };
+export { DebouncedStore };
+export { addHook } from "./utils/addHook";
+export { getPaginate } from "./utils/getPaginate";
+export { isMulti } from "./utils/isMulti";
+export { isPaginated } from "./utils/isPaginated";
+export { mergeQuery } from "./utils/mergeQuery/index";
+export { mergeArrays } from "./utils/mergeQuery/mergeArrays";
+export { pushSet } from "./utils/pushSet";
+export { setResultEmpty } from "./utils/setResultEmpty";
+export { markHookForSkip } from "./utils/markHookForSkip";
+export { shouldSkip } from "./utils/shouldSkip";
+export { filterQuery } from "./utils/filterQuery";
+export * from "./types";

package/dist/esm/index.js

@@ -0,0 +1,31 @@
+// hooks
+import { checkMulti } from "./hooks/checkMulti";
+import { setData } from "./hooks/setData";
+import { runPerItem } from "./hooks/runPerItem";
+export const hooks = {
+    checkMulti,
+    setData,
+    runPerItem
+};
+export { checkMulti };
+export { setData };
+export { runPerItem };
+import { debounceMixin, DebouncedStore } from "./mixins/debounce-mixin";
+export const mixins = {
+    debounceMixin,
+    DebouncedStore
+};
+export { debounceMixin };
+export { DebouncedStore };
+export { addHook } from "./utils/addHook";
+export { getPaginate } from "./utils/getPaginate";
+export { isMulti } from "./utils/isMulti";
+export { isPaginated } from "./utils/isPaginated";
+export { mergeQuery } from "./utils/mergeQuery/index";
+export { mergeArrays } from "./utils/mergeQuery/mergeArrays";
+export { pushSet } from "./utils/pushSet";
+export { setResultEmpty } from "./utils/setResultEmpty";
+export { markHookForSkip } from "./utils/markHookForSkip";
+export { shouldSkip } from "./utils/shouldSkip";
+export { filterQuery } from "./utils/filterQuery";
+export * from "./types";

package/dist/esm/mixins/debounce-mixin/DebouncedStore.d.ts

@@ -0,0 +1,15 @@
+import type { DebouncedFunc } from "lodash";
+import type { Application, Id } from "@feathersjs/feathers";
+import type { DebouncedFunctionApp, DebouncedStoreOptions } from "../../types";
+export declare const makeDefaultOptions: () => DebouncedStoreOptions;
+export declare class DebouncedStore {
+    private _app;
+    private _options;
+    private _isRunningById;
+    _queueById: Record<string, DebouncedFunc<((id: Id, action: DebouncedFunctionApp) => void | Promise<void>)>>;
+    add: (id: Id, action: (app?: Application<{}> | undefined) => void | Promise<void>) => void | Promise<void> | undefined;
+    constructor(app: Application, options?: Partial<DebouncedStoreOptions>);
+    private unbounced;
+    private debounceById;
+    cancel(id: Id): void;
+}

package/dist/esm/mixins/debounce-mixin/DebouncedStore.js

@@ -0,0 +1,46 @@
+import _debounce from "lodash/debounce";
+export const makeDefaultOptions = () => {
+    return {
+        leading: false,
+        maxWait: undefined,
+        trailing: true,
+        wait: 100
+    };
+};
+export class DebouncedStore {
+    constructor(app, options) {
+        this._app = app;
+        this._options = Object.assign(makeDefaultOptions(), options);
+        this._queueById = {};
+        this._isRunningById = {};
+        //this._waitingById = {};
+        this.add = this.debounceById(this.unbounced, this._options.wait, {
+            leading: this._options.leading,
+            maxWait: this._options.maxWait,
+            trailing: this._options.trailing
+        });
+    }
+    async unbounced(id, action) {
+        if (this._queueById[id] === undefined) {
+            return;
+        }
+        delete this._queueById[id];
+        this._isRunningById[id] = true;
+        await action(this._app);
+        delete this._isRunningById[id];
+    }
+    debounceById(func, wait, options) {
+        return (id, action) => {
+            if (typeof this._queueById[id] === "function") {
+                return this._queueById[id](id, action);
+            }
+            this._queueById[id] = _debounce((id, action) => {
+                this.unbounced(id, action);
+            }, wait, { ...options, leading: false }); // leading required for return promise
+            return this._queueById[id](id, action);
+        };
+    }
+    cancel(id) {
+        delete this._queueById[id];
+    }
+}

package/dist/esm/mixins/debounce-mixin/index.d.ts

@@ -0,0 +1,5 @@
+import { DebouncedStore } from "./DebouncedStore";
+import type { Application } from "@feathersjs/feathers";
+import type { InitDebounceMixinOptions } from "../../types";
+export declare function debounceMixin(options?: Partial<InitDebounceMixinOptions>): ((app: Application) => void);
+export { DebouncedStore };

package/dist/esm/mixins/debounce-mixin/index.js

@@ -0,0 +1,20 @@
+import { DebouncedStore, makeDefaultOptions } from "./DebouncedStore";
+export function debounceMixin(options) {
+    return (app) => {
+        options = options || {};
+        const defaultOptions = Object.assign(makeDefaultOptions(), options?.default);
+        app.mixins.push((service, path) => {
+            // if path is on blacklist, don't add debouncedStore to service
+            if (options?.blacklist && options.blacklist.includes(path))
+                return;
+            // if service already has registered something on `debouncedStore`
+            if (service.debouncedStore) {
+                console.warn(`[feathers-utils] service: '${path}' already has a property 'debouncedStore'. Mixin will skip creating a new debouncedStore`);
+                return;
+            }
+            const serviceOptions = Object.assign({}, defaultOptions, options?.[path]);
+            service.debouncedStore = new DebouncedStore(app, serviceOptions);
+        });
+    };
+}
+export { DebouncedStore };

package/dist/esm/types.d.ts

@@ -0,0 +1,59 @@
+import type { Application, Service } from "@feathersjs/feathers";
+export declare type Path = Array<string | number>;
+export declare type HookType = "before" | "after" | "error";
+export declare type ServiceMethodName = "find" | "get" | "create" | "update" | "patch" | "remove";
+export declare type Handle = "target" | "source" | "combine" | "intersect" | "intersectOrFull";
+export declare type FirstLast = "first" | "last";
+export interface HookSetDataOptions {
+    allowUndefined?: boolean;
+    overwrite?: boolean;
+}
+export interface AddHookOptions {
+    types: HookType[];
+    methods: ServiceMethodName[];
+    orderByType: Record<HookType, FirstLast>;
+    whitelist?: string[];
+    blacklist?: string[];
+}
+export interface HookRunPerItemOptions {
+    wait?: boolean;
+}
+export interface InitDebounceMixinOptions {
+    default: Partial<DebouncedStoreOptions>;
+    blacklist: string[];
+    [key: string]: unknown;
+}
+export declare type DebouncedFunctionApp = (app?: Application) => void | Promise<void>;
+export interface DebouncedStoreOptions {
+    leading: boolean;
+    maxWait: number | undefined;
+    trailing: boolean;
+    wait: number;
+}
+export interface PushSetOptions {
+    unique?: boolean;
+}
+export declare type ActionOnEmptyIntersect = (target: unknown, source: unknown, prependKey: Path) => void;
+export interface MergeQueryOptions<T> extends FilterQueryOptions<T> {
+    defaultHandle: Handle;
+    actionOnEmptyIntersect: ActionOnEmptyIntersect;
+    useLogicalConjunction: boolean;
+    handle?: {
+        [key: string]: Handle;
+    };
+}
+export interface FilterQueryOptions<T> {
+    service?: Service<T>;
+    operators?: string[];
+    filters?: string[];
+}
+export interface PlainFilterQueryOptions {
+    operators?: string[];
+    filters?: string[];
+}
+export interface FilterQueryResult {
+    filters: Record<string, unknown>;
+    query: Record<string, unknown>;
+    paginate?: unknown;
+    [key: string]: unknown;
+}

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//#endregion

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

@@ -0,0 +1,3 @@
+import type { Application } from "@feathersjs/feathers";
+import type { AddHookOptions } from "../types";
+export declare const addHook: (app: Application, hook: unknown, options: AddHookOptions) => void;

package/dist/esm/utils/addHook.js

@@ -0,0 +1,36 @@
+const defaultOptions = () => {
+    return {
+        whitelist: ["*"],
+        blacklist: []
+    };
+};
+export const addHook = (app, hook, options) => {
+    options = Object.assign(defaultOptions(), options);
+    const { types, methods, whitelist, blacklist, orderByType } = options;
+    if (types.some(x => !(Object.keys(orderByType).includes(x)))) {
+        throw new Error("'feathers-utils/addHook': some types in 'orderByType' are undefined");
+    }
+    if (Object.keys(orderByType).some(type => !((["first", "last"]).includes(orderByType[type])))) {
+        throw new Error("'feathers-utils/addHook': only allowed values for 'orderByType' are 'first' or 'last'");
+    }
+    const allServices = app.services;
+    for (const servicePath in allServices) {
+        if (!Object.prototype.hasOwnProperty.call(allServices, servicePath)) {
+            continue;
+        }
+        const service = app.service(servicePath);
+        if (blacklist && blacklist.includes(servicePath)) {
+            continue;
+        }
+        if (whitelist && !whitelist.includes("*") && !whitelist.includes(servicePath)) {
+            continue;
+        }
+        types.forEach(type => {
+            const order = orderByType[type];
+            const unshiftOrPush = (order === "first") ? "unshift" : "push";
+            methods.forEach(method => {
+                service.__hooks[type][method][unshiftOrPush](hook);
+            });
+        });
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { FilterQueryOptions, FilterQueryResult } from "../types";
+import type { Query } from "@feathersjs/feathers";
+export declare function filterQuery<T>(query: Query, options?: FilterQueryOptions<T>): FilterQueryResult;

package/dist/esm/utils/filterQuery.js

@@ -0,0 +1,28 @@
+import { filterQuery as plainFilterQuery } from "@feathersjs/adapter-commons";
+export function filterQuery(query, options) {
+    query = query || {};
+    options = options || {};
+    if (options?.service) {
+        const { service } = options;
+        const operators = options.operators
+            ? options.operators
+            : service.options?.whitelist;
+        const filters = options.filters
+            ? options.filters
+            : service.options?.filters;
+        const optionsForFilterQuery = {};
+        if (operators) {
+            optionsForFilterQuery.operators = operators;
+        }
+        if (filters) {
+            optionsForFilterQuery.filters = filters;
+        }
+        if (typeof service?.filterQuery === "function") {
+            return service.filterQuery({ query }, optionsForFilterQuery);
+        }
+        else {
+            return plainFilterQuery(query, optionsForFilterQuery);
+        }
+    }
+    return plainFilterQuery(query, options);
+}

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

@@ -0,0 +1,2 @@
+import { HookContext, PaginationOptions } from "@feathersjs/feathers";
+export declare const getPaginate: (context: HookContext) => PaginationOptions | undefined;

package/dist/esm/utils/getPaginate.js

@@ -0,0 +1,14 @@
+export const getPaginate = (context) => {
+    if (Object.prototype.hasOwnProperty.call(context.params, "paginate")) {
+        return context.params.paginate || undefined;
+    }
+    if (context.params.paginate === false) {
+        return undefined;
+    }
+    let options = context.service.options || {};
+    options = {
+        ...options,
+        ...context.params.adapter
+    };
+    return options.paginate || undefined;
+};

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

@@ -0,0 +1,2 @@
+import type { HookContext } from "@feathersjs/feathers";
+export declare const isMulti: (context: HookContext) => boolean;

package/dist/esm/utils/isMulti.js

@@ -0,0 +1,17 @@
+export const isMulti = (context) => {
+    const { method } = context;
+    if (method === "find") {
+        return true;
+    }
+    else if (["patch", "remove"].includes(method)) {
+        return context.id == null;
+    }
+    else if (method === "create") {
+        const items = context.type === "before" ? context.data : context.result;
+        return Array.isArray(items);
+    }
+    else if (["get", "update"].includes(method)) {
+        return false;
+    }
+    return false;
+};

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

@@ -0,0 +1,2 @@
+import { HookContext } from "@feathersjs/feathers";
+export declare const isPaginated: (context: HookContext) => boolean;

package/dist/esm/utils/isPaginated.js

@@ -0,0 +1,8 @@
+import { getPaginate } from "./getPaginate";
+export const isPaginated = (context) => {
+    if (context.params.paginate === false) {
+        return false;
+    }
+    const paginate = getPaginate(context);
+    return !!paginate;
+};

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

@@ -0,0 +1,3 @@
+import type { HookContext } from "@feathersjs/feathers";
+import type { HookType } from "feathers-hooks-common/types";
+export declare function markHookForSkip<T>(hookName: string, type: "all" | HookType | HookType[], context?: Partial<HookContext<T>>): Partial<HookContext<T>>;

package/dist/esm/utils/markHookForSkip.js

@@ -0,0 +1,14 @@
+import { pushSet } from "./pushSet";
+export function markHookForSkip(hookName, type, context) {
+    context = context || {};
+    const params = context.params || {};
+    const types = (Array.isArray(type)) ? type : [type];
+    types.forEach(t => {
+        const combinedName = (t === "all")
+            ? hookName
+            : `${type}:${hookName}`;
+        pushSet(params, ["skipHooks"], combinedName, { unique: true });
+    });
+    context.params = params;
+    return context;
+}

package/dist/esm/utils/mergeQuery/index.d.ts

@@ -0,0 +1,3 @@
+import type { Query } from "@feathersjs/feathers";
+import type { MergeQueryOptions } from "../../types";
+export declare function mergeQuery<T>(target: Query, source: Query, options?: Partial<MergeQueryOptions<T>>): Query;