feathers-utils 2.0.0-9 → 2.1.0

package/dist/index.d.ts

@@ -1,5 +1,262 @@
-export * from "./hooks";
-export * from "./mixins";
-export * from "./utils";
-export * from "./filters";
-export * from "./types";
+import * as _feathersjs_feathers from '@feathersjs/feathers';
+import { HookContext, Application, Id, Query } from '@feathersjs/feathers';
+import { HookContext as HookContext$1, Application as Application$1 } from '@feathersjs/feathers/lib';
+import { PropertyPath, DebouncedFunc } from 'lodash';
+import { AdapterBase, FilterQueryOptions as FilterQueryOptions$1, PaginationOptions } from '@feathersjs/adapter-commons';
+import { HookType } from 'feathers-hooks-common';
+
+/**
+ * hook to check if context is multi patch/remove and if the service allows it
+ */
+declare function checkMulti<H extends HookContext = HookContext>(): (context: H) => H;
+
+type MaybeArray<T> = T | T[];
+type Promisable<T> = T | Promise<T>;
+type Path = Array<string | number>;
+type ReturnAsyncHook = (context: HookContext$1) => Promise<HookContext$1>;
+
+interface CreateRelatedOptions<S = Record<string, any>> {
+    service: keyof S;
+    multi?: boolean;
+    data: (item: any, context: HookContext) => Promisable<Record<string, any>>;
+    createItemsInDataArraySeparately?: boolean;
+}
+/**
+ * hook to create related items
+ */
+declare function createRelated<S = Record<string, any>, H extends HookContext = HookContext>({ service, multi, data, createItemsInDataArraySeparately, }: CreateRelatedOptions<S>): (context: H) => Promise<H>;
+
+type GetItemsIsArrayOptions = {
+    from: "data" | "result" | "automatic";
+};
+interface GetItemsIsArrayResult<T = any> {
+    items: T[];
+    isArray: boolean;
+}
+declare const getItemsIsArray: <T = any, H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>>(context: H, options?: GetItemsIsArrayOptions) => GetItemsIsArrayResult<T>;
+
+interface HookForEachOptions {
+    wait?: "sequential" | "parallel" | false;
+    items?: GetItemsIsArrayOptions["from"];
+}
+declare const forEach: (actionPerItem: (item: any, context: HookContext) => Promisable<any>, _options?: HookForEachOptions) => ReturnAsyncHook;
+
+type OnDeleteAction = "cascade" | "set null";
+interface OnDeleteOptions {
+    keyThere: string;
+    keyHere: string;
+    onDelete: OnDeleteAction;
+    blocking?: boolean;
+}
+/**
+ * hook to manipulate related items on delete
+ */
+declare function onDelete<S = Record<string, any>, H extends HookContext = HookContext>(service: keyof S, { keyThere, keyHere, onDelete, blocking, }: OnDeleteOptions): (context: H) => Promise<H>;
+
+/**
+ * Parse fields to date or number
+ * skips undefined fields
+ */
+declare const parseFields: (type: "date" | "number", options: {
+    fields: string[];
+}) => (context: HookContext) => HookContext<_feathersjs_feathers.Application<any, any>, any>;
+
+interface RemoveRelatedOptions<S = Record<string, any>> {
+    service: keyof S;
+    keyThere: string;
+    keyHere: string;
+    blocking?: boolean;
+}
+/**
+ * hook to remove related items
+ */
+declare function removeRelated<S = Record<string, any>, H extends HookContext = HookContext>({ service, keyThere, keyHere, blocking, }: RemoveRelatedOptions<S>): (context: H) => Promise<H>;
+
+interface HookRunPerItemOptions {
+    wait?: boolean;
+}
+/**
+ * hook to run a hook for each item in the context
+ * uses `context.result` if it is existent. otherwise uses context.data
+ */
+declare const runPerItem: <H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>>(actionPerItem: (item: any, context: H) => Promisable<any>, _options?: HookRunPerItemOptions) => (context: H) => Promise<H>;
+
+type Predicate<T = any> = (item: T) => boolean;
+type PredicateWithContext<T = any> = (item: T, context: HookContext) => boolean;
+
+interface HookSetDataOptions {
+    allowUndefined?: boolean;
+    overwrite?: boolean | PredicateWithContext;
+}
+/**
+ * hook to set properties on `context.result` (if existent) or `context.data` (otherwise)
+ */
+declare function setData<H extends HookContext = HookContext>(from: PropertyPath, to: PropertyPath, _options?: HookSetDataOptions): (context: H) => H;
+
+interface InitDebounceMixinOptions {
+    default: Partial<DebouncedStoreOptions>;
+    blacklist: string[];
+    [key: string]: unknown;
+}
+type DebouncedFunctionApp = (app?: Application) => void | Promise<void>;
+interface DebouncedStoreOptions {
+    leading: boolean;
+    maxWait: number | undefined;
+    trailing: boolean;
+    wait: number;
+}
+
+declare const makeDefaultOptions: () => DebouncedStoreOptions;
+type DebouncedService<T = any> = T & {
+    debouncedStore: DebouncedStore;
+};
+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) => void | Promise<void>) => void | Promise<void> | undefined;
+    constructor(app: Application, options?: Partial<DebouncedStoreOptions>);
+    private unbounced;
+    private debounceById;
+    cancel(id: Id): void;
+}
+
+declare function debounceMixin(options?: Partial<InitDebounceMixinOptions>): (app: Application$1) => void;
+
+interface FilterQueryOptions<T> {
+    service?: AdapterBase<T>;
+    operators?: FilterQueryOptions$1["operators"];
+    filters?: FilterQueryOptions$1["filters"];
+}
+declare function filterQuery<T>(query: Query, _options?: FilterQueryOptions<T>): any;
+
+type Handle = "target" | "source" | "combine" | "intersect" | "intersectOrFull";
+type FirstLast = "first" | "last";
+type ActionOnEmptyIntersect = (target: unknown, source: unknown, prependKey: Path) => void;
+interface MergeQueryOptions<T> extends FilterQueryOptions<T> {
+    defaultHandle: Handle;
+    actionOnEmptyIntersect: ActionOnEmptyIntersect;
+    useLogicalConjunction: boolean;
+    handle?: {
+        [key: string]: Handle;
+    };
+}
+
+declare function mergeArrays<T>(targetArr: T[], sourceArr: T[], handle: Handle, prependKey?: Path, actionOnEmptyIntersect?: ActionOnEmptyIntersect): T[] | undefined;
+
+/**
+ * Merges two queries into one.
+ * @param target Query to be merged into
+ * @param source Query to be merged from
+ * @param _options
+ * @returns Query
+ */
+declare function mergeQuery<T = any>(target: Query, source: Query, _options?: Partial<MergeQueryOptions<T>>): Query;
+
+/**
+ * util to get paginate options from context
+ * 1. it uses `context.params.paginate` if it exists
+ * 2. it uses `service.options.paginate` if it exists
+ * 3. it uses `context.params.adapter` if it exists
+ */
+declare const getPaginate: <H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>>(context: H) => PaginationOptions | undefined;
+
+/**
+ * util to check if a hook is a multi hook:
+ * - find: true
+ * - get: false
+ * - create: `context.data` is an array
+ * - update: false
+ * - patch: `context.id == null`
+ * - remove: `context.id == null`
+ */
+declare const isMulti: <H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>>(context: H) => boolean;
+
+/**
+ * util to check if a hook is a paginated hook using `getPaginate`
+ */
+declare const isPaginated: <H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>>(context: H) => boolean;
+
+/**
+ * util to mark a hook for skip, has to be used with `shouldSkip`
+ */
+declare function markHookForSkip<H extends HookContext = HookContext>(hookName: string, type: "all" | MaybeArray<HookType>, context?: H): H | undefined;
+
+interface PushSetOptions {
+    unique?: boolean;
+}
+/**
+ * util to push a value to an array at a given path in an object
+ */
+declare const pushSet: (obj: Record<string, unknown>, path: string | Path, val: unknown, options?: PushSetOptions) => unknown[];
+
+/**
+ * util to set `context.result` to an empty array or object, depending on the hook type
+ */
+declare const setResultEmpty: <H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>>(context: H) => H;
+
+type ShouldSkipOptions = {
+    notSkippable?: boolean;
+};
+/**
+ * util to detect if a hook should be skipped
+ */
+declare const shouldSkip: <H extends HookContext<_feathersjs_feathers.Application<any, any>, any> = HookContext<_feathersjs_feathers.Application<any, any>, any>, O extends ShouldSkipOptions = ShouldSkipOptions>(hookName: string, context: H, options?: O | undefined) => boolean;
+
+/**
+ * util to validate a query for operators
+ */
+declare const validateQueryProperty: (query: any, operators?: string[]) => Query;
+
+declare const filterArray: <T extends string[]>(...keys: T) => { [key in T[number]]: (value: any, options: FilterQueryOptions$1) => any; };
+
+declare const filterObject: <T extends string[]>(...keys: T) => { [key in T[number]]: (value: any, options: FilterQueryOptions$1) => any; };
+
+type Single<T> = T extends Array<infer U> ? U : T;
+type AsArray<T> = T extends any[] ? T : [T];
+type InferCreateData<S> = S extends {
+    create: (data: infer D, params: any) => any;
+} ? D : never;
+type InferCreateDataSingle<S> = Single<InferCreateData<S>>;
+type InferUpdateData<S> = S extends {
+    update: (id: any, data: infer D, params: any) => any;
+} ? D : never;
+type InferPatchData<S> = S extends {
+    patch: (id: any, data: infer D, params: any) => any;
+} ? D : never;
+type InferGetResult<S> = S extends {
+    get: (id: any, params: any) => infer R;
+} ? Awaited<R> : never;
+type InferFindResult<S> = S extends {
+    find: (params: any) => infer R;
+} ? Awaited<R> : never;
+type InferCreateResult<S, D = unknown> = S extends {
+    create: (data: any, params: any) => infer R;
+} ? D extends any[] ? AsArray<Awaited<R>> : D extends InferCreateDataSingle<S> ? Single<Awaited<R>> : Awaited<R> : never;
+type InferCreateResultSingle<S> = Single<InferCreateResult<S>>;
+type InferUpdateResult<S> = S extends {
+    update: (id: any, data: any, params: any) => infer R;
+} ? Awaited<R> : never;
+type InferPatchResult<S, IdOrNullable = any> = S extends {
+    patch: (id: Id, data: any, params: any) => infer R;
+} ? IdOrNullable extends Id ? Single<Awaited<R>> : IdOrNullable extends null ? AsArray<Awaited<R>> : Awaited<R> : never;
+type InferRemoveResult<S, IdOrNullable = any> = S extends {
+    remove: (id: IdOrNullable, params: any) => infer R;
+} ? IdOrNullable extends Id ? Single<Awaited<R>> : IdOrNullable extends null ? AsArray<Awaited<R>> : Awaited<R> : never;
+type GetService<App extends Application, Path extends string> = App["services"][Path];
+type InferGetResultFromPath<App extends Application, Path extends string> = InferGetResult<GetService<App, Path>>;
+type InferFindResultFromPath<App extends Application, Path extends string> = InferFindResult<GetService<App, Path>>;
+type InferCreateDataFromPath<App extends Application, Path extends string> = InferCreateData<GetService<App, Path>>;
+type InferCreateDataSingleFromPath<App extends Application, Path extends string> = InferCreateDataSingle<GetService<App, Path>>;
+type InferCreateResultFromPath<App extends Application, Path extends string, D = unknown> = InferCreateResult<GetService<App, Path>, D>;
+type InferCreateResultSingleFromPath<App extends Application, Path extends string> = InferCreateResultSingle<GetService<App, Path>>;
+type InferUpdateDataFromPath<App extends Application, Path extends string> = InferUpdateData<GetService<App, Path>>;
+type InferPatchDataFromPath<App extends Application, Path extends string> = InferPatchData<GetService<App, Path>>;
+type InferUpdateResultFromPath<App extends Application, Path extends string> = InferUpdateResult<GetService<App, Path>>;
+type InferPatchResultFromPath<App extends Application, Path extends string, IdOrNullable = any> = InferPatchResult<GetService<App, Path>, IdOrNullable>;
+type InferRemoveResultFromPath<App extends Application, Path extends string, IdOrNullable = any> = InferRemoveResult<GetService<App, Path>, IdOrNullable>;
+type InferDataFromPath<App extends Application, Path extends string, Method extends "create" | "update" | "patch"> = Method extends "create" ? InferCreateDataFromPath<App, Path> : Method extends "update" ? InferUpdateDataFromPath<App, Path> : Method extends "patch" ? InferPatchDataFromPath<App, Path> : never;
+type InferResultFromPath<App extends Application, Path extends string, Method extends "get" | "find" | "create" | "update" | "patch" | "remove"> = Method extends "get" ? InferGetResultFromPath<App, Path> : Method extends "find" ? InferFindResultFromPath<App, Path> : Method extends "create" ? InferCreateResultFromPath<App, Path> : Method extends "update" ? InferUpdateResultFromPath<App, Path> : Method extends "patch" ? InferPatchResultFromPath<App, Path> : Method extends "remove" ? InferRemoveResultFromPath<App, Path> : never;
+
+export { ActionOnEmptyIntersect, CreateRelatedOptions, DebouncedFunctionApp, DebouncedService, DebouncedStore, DebouncedStoreOptions, FilterQueryOptions, FirstLast, GetItemsIsArrayOptions, GetItemsIsArrayResult, GetService, Handle, HookForEachOptions, HookRunPerItemOptions, HookSetDataOptions, InferCreateData, InferCreateDataFromPath, InferCreateDataSingle, InferCreateDataSingleFromPath, InferCreateResult, InferCreateResultFromPath, InferCreateResultSingle, InferCreateResultSingleFromPath, InferDataFromPath, InferFindResult, InferFindResultFromPath, InferGetResult, InferGetResultFromPath, InferPatchData, InferPatchDataFromPath, InferPatchResult, InferPatchResultFromPath, InferRemoveResult, InferRemoveResultFromPath, InferResultFromPath, InferUpdateData, InferUpdateDataFromPath, InferUpdateResult, InferUpdateResultFromPath, InitDebounceMixinOptions, MergeQueryOptions, OnDeleteAction, OnDeleteOptions, Predicate, PredicateWithContext, PushSetOptions, RemoveRelatedOptions, ShouldSkipOptions, checkMulti, createRelated, debounceMixin, filterArray, filterObject, filterQuery, forEach, getItemsIsArray, getPaginate, isMulti, isPaginated, makeDefaultOptions, markHookForSkip, mergeArrays, mergeQuery, onDelete, parseFields, pushSet, removeRelated, runPerItem, setData, setResultEmpty, shouldSkip, validateQueryProperty };