feathers-utils 2.0.0-2 → 2.0.0-4

package/src/hooks/runPerItem.ts

@@ -1,26 +1,35 @@
 import { shouldSkip } from "../utils/shouldSkip";
 
-import type { HookRunPerItemOptions, ReturnAsyncHook, Promisable } from "../types";
 import type { HookContext } from "@feathersjs/feathers";
 import { getItemsIsArray } from "../utils/getItemsIsArray";
+import type { Promisable } from "../typesInternal";
+
+export interface HookRunPerItemOptions {
+  wait?: boolean;
+}
 
 const makeOptions = (
   options?: HookRunPerItemOptions
 ): Required<HookRunPerItemOptions> => {
   options = options || {};
-  return Object.assign({
-    wait: true
-  }, options);
+  return Object.assign(
+    {
+      wait: true,
+    },
+    options
+  );
 };
 
-export const runPerItem = (
+export const runPerItem = <H extends HookContext = HookContext>(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  actionPerItem: (item: any, context: HookContext) => Promisable<any>, 
+  actionPerItem: (item: any, context: H) => Promisable<any>,
   _options?: HookRunPerItemOptions
-): ReturnAsyncHook => {
+) => {
   const options = makeOptions(_options);
-  return async (context: HookContext): Promise<HookContext> => {
-    if (shouldSkip("runForItems", context)) { return context; }
+  return async (context: H) => {
+    if (shouldSkip("runForItems", context)) {
+      return context;
+    }
 
     const { items } = getItemsIsArray(context);
 
@@ -34,4 +43,4 @@ export const runPerItem = (
 
     return context;
   };
-};
+};

package/src/hooks/setData.ts

@@ -7,25 +7,29 @@ import { getItemsIsArray } from "../utils/getItemsIsArray";
 
 import type { HookContext } from "@feathersjs/feathers";
 import type { PropertyPath } from "lodash";
+import type { PredicateWithContext } from "../types";
 
-import type {
-  HookSetDataOptions, 
-  ReturnSyncHook 
-} from "../types";
+export interface HookSetDataOptions {
+  allowUndefined?: boolean;
+  overwrite?: boolean | PredicateWithContext;
+}
 
 const defaultOptions: Required<HookSetDataOptions> = {
   allowUndefined: false,
-  overwrite: true
+  overwrite: true,
 };
 
-export function setData(
-  from: PropertyPath, 
-  to: PropertyPath, 
+export function setData<H extends HookContext = HookContext>(
+  from: PropertyPath,
+  to: PropertyPath,
   _options?: HookSetDataOptions
-): ReturnSyncHook {
-  const options: Required<HookSetDataOptions> = Object.assign({}, defaultOptions, _options);
-  return (context: HookContext): HookContext => {
-
+) {
+  const options: Required<HookSetDataOptions> = Object.assign(
+    {},
+    defaultOptions,
+    _options
+  );
+  return (context: H) => {
     const { items } = getItemsIsArray(context);
 
     if (!_has(context, from)) {
@@ -33,7 +37,10 @@ export function setData(
         return context;
       }
 
-      if (!options.overwrite && items.every((item: Record<string, unknown>) => _has(item, to))) {
+      if (
+        !options.overwrite &&
+        items.every((item: Record<string, unknown>) => _has(item, to))
+      ) {
         return context;
       }
 
@@ -50,11 +57,13 @@ export function setData(
         overwrite = options.overwrite;
       }
 
-      if (!overwrite && _has(item, to)) { return; }
+      if (!overwrite && _has(item, to)) {
+        return;
+      }
 
       _set(item, to, val);
     });
 
     return context;
   };
-}
+}

package/src/index.ts

@@ -1,50 +1,33 @@
 // hooks
-import { checkMulti } from "./hooks/checkMulti";
-import { setData } from "./hooks/setData";
+export * from "./hooks/checkMulti";
+export * from "./hooks/createRelated";
+export * from "./hooks/onDelete";
+export * from "./hooks/removeRelated";
+export * from "./hooks/runPerItem";
+export * from "./hooks/setData";
 
-import { runPerItem } from "./hooks/runPerItem";
+// mixins
+export * from "./mixins/debounce-mixin";
 
-export const hooks = {
-  checkMulti,
-  setData,
-  runPerItem
-};
+// utils
+export * from "./utils/isMulti";
 
-export { checkMulti };
-export { createRelated } from "./hooks/createRelated";
-export { setData };
-export { removeRelated } from "./hooks/removeRelated";
-export { runPerItem };
+export * from "./utils/getPaginate";
+export * from "./utils/isPaginated";
 
-import { debounceMixin, DebouncedService, DebouncedStore } from "./mixins/debounce-mixin";
+export * from "./utils/mergeQuery";
+export * from "./utils/pushSet";
+export * from "./utils/setResultEmpty";
+export * from "./utils/filterQuery";
+export * from "./utils/getItemsIsArray";
 
-export const mixins = {
-  debounceMixin,
-  DebouncedStore
-};
-
-export { debounceMixin };
-export { DebouncedService };
-export { DebouncedStore };
-
-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 { filterQuery } from "./utils/filterQuery";
-export { getItemsIsArray } from "./utils/getItemsIsArray";
-export { onDelete } from "./hooks/onDelete";
-export { shouldSkip } from "./utils/shouldSkip";
-
-export { validateQueryProperty } from "./utils/validateQueryProperty";
+export * from "./utils/shouldSkip";
+export * from "./utils/markHookForSkip";
 
+export * from "./utils/validateQueryProperty";
 
 // query filters
 export { filterArray } from "./filters/array";
+export { filterObject } from "./filters/object";
 
 export * from "./types";

package/src/mixins/debounce-mixin/DebouncedStore.ts

@@ -2,26 +2,31 @@ import _debounce from "lodash/debounce.js";
 
 import type { DebouncedFunc } from "lodash";
 import type { Application, Id } from "@feathersjs/feathers";
-
-import type {
-  DebouncedFunctionApp,
-  DebouncedStoreOptions
-} from "../../types";
+import type { DebouncedFunctionApp, DebouncedStoreOptions } from "./types";
 
 export const makeDefaultOptions = (): DebouncedStoreOptions => {
   return {
     leading: false,
     maxWait: undefined,
     trailing: true,
-    wait: 100
+    wait: 100,
   };
 };
 
+export type DebouncedService<T = any> = T & {
+  debouncedStore: DebouncedStore;
+};
+
 export class DebouncedStore {
   private _app: Application;
   private _options: DebouncedStoreOptions;
   private _isRunningById: Record<string, unknown>;
-  _queueById: Record<string, DebouncedFunc<((id: Id, action: DebouncedFunctionApp) => void | Promise<void>)>>;
+  _queueById: Record<
+    string,
+    DebouncedFunc<
+      (id: Id, action: DebouncedFunctionApp) => void | Promise<void>
+    >
+  >;
   //_waitingById: Record<string, WaitingObject>;
   add;
   constructor(app: Application, options?: Partial<DebouncedStoreOptions>) {
@@ -31,15 +36,11 @@ export class DebouncedStore {
     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
-      }
-    );
+    this.add = this.debounceById(this.unbounced, this._options.wait, {
+      leading: this._options.leading,
+      maxWait: this._options.maxWait,
+      trailing: this._options.trailing,
+    });
   }
 
   private async unbounced(id: Id, action: DebouncedFunctionApp): Promise<void> {
@@ -53,18 +54,22 @@ export class DebouncedStore {
   }
 
   private debounceById(
-    func: ((id: Id, action: DebouncedFunctionApp) => Promise<void>), 
-    wait: number, 
+    func: (id: Id, action: DebouncedFunctionApp) => Promise<void>,
+    wait: number,
     options?: Partial<DebouncedStoreOptions>
   ) {
-    return (id: Id, action: ((app?: Application) => void | Promise<void>)) => {
+    return (id: Id, action: (app?: Application) => void | Promise<void>) => {
       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
+
+      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);
     };
   }
@@ -72,4 +77,4 @@ export class DebouncedStore {
   cancel(id: Id): void {
     delete this._queueById[id];
   }
-}
+}

package/src/mixins/debounce-mixin/debounceMixin.ts

@@ -0,0 +1,33 @@
+import type { Application } from "@feathersjs/feathers/lib";
+import { DebouncedStore, makeDefaultOptions } from "./DebouncedStore";
+import type { DebouncedStoreOptions, InitDebounceMixinOptions } from "./types";
+
+export function debounceMixin(
+  options?: Partial<InitDebounceMixinOptions>
+): (app: Application) => void {
+  return (app: Application): void => {
+    options = options || {};
+    const defaultOptions = Object.assign(
+      makeDefaultOptions(),
+      options?.default
+    );
+
+    app.mixins.push((service: any, 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 as DebouncedStoreOptions
+      );
+    });
+  };
+}

package/src/mixins/debounce-mixin/index.ts

@@ -1,39 +1,3 @@
-import {
-  DebouncedStore,
-  makeDefaultOptions
-} from "./DebouncedStore";
-
-import type { Application, FeathersService } from "@feathersjs/feathers";
-
-import type {
-  InitDebounceMixinOptions,
-  DebouncedStoreOptions,
-} from "../../types";
-
-export type DebouncedService = FeathersService & {
-  debouncedStore: DebouncedStore;
-};
-
-export function debounceMixin(
-  options?: Partial<InitDebounceMixinOptions>
-): ((app: Application) => void) {
-  return (app: Application): void => {
-    options = options || {};
-    const defaultOptions = Object.assign(makeDefaultOptions(), options?.default);
-    
-    app.mixins.push((service: any, 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 as DebouncedStoreOptions);
-    });
-  };
-}
-
-export { DebouncedStore };
+export * from "./types";
+export * from "./DebouncedStore";
+export * from "./debounceMixin";

package/src/mixins/debounce-mixin/types.ts

@@ -0,0 +1,16 @@
+import type { Application } from "@feathersjs/feathers";
+
+export interface InitDebounceMixinOptions {
+  default: Partial<DebouncedStoreOptions>;
+  blacklist: string[];
+  [key: string]: unknown;
+}
+
+export type DebouncedFunctionApp = (app?: Application) => void | Promise<void>;
+
+export interface DebouncedStoreOptions {
+  leading: boolean;
+  maxWait: number | undefined;
+  trailing: boolean;
+  wait: number;
+}

package/src/types.ts

@@ -1,120 +1,9 @@
-import type { Application, HookContext } from "@feathersjs/feathers";
-import type { 
-  AdapterBase,
-  FilterQueryOptions as PlainFilterQueryOptions
-} from "@feathersjs/adapter-commons";
-
-export type Path = Array<string|number>;
-export type MaybeArray<T> = T | T[]
-export type Promisable<T> = T | Promise<T>
-
-export type HookType = "before" | "after" | "error";
-export type ServiceMethodName = "find" | "get" | "create" | "update" | "patch" | "remove";
-export type ReturnSyncHook = (context: HookContext) => HookContext
-export type ReturnAsyncHook = (context: HookContext) => Promise<HookContext>
-
-export type Handle = "target" | "source" | "combine" | "intersect"| "intersectOrFull";
-export type FirstLast = "first" | "last";
+import type { HookContext } from "@feathersjs/feathers";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Predicate<T = any> = (item: T) => boolean
+export type Predicate<T = any> = (item: T) => boolean;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type PredicateWithContext<T = any> = (item: T, context: HookContext) => boolean
-
-//#region hooks
-
-export interface HookSetDataOptions {
-  allowUndefined?: boolean
-  overwrite?: boolean | PredicateWithContext
-}
-
-export interface AddHookOptions {
-  types: HookType[],
-  methods: ServiceMethodName[],
-  orderByType: Record<HookType, FirstLast>
-  whitelist?: string[],
-  blacklist?: string[],
-}
-
-export interface HookRunPerItemOptions {
-  wait?: boolean
-}
-
-export interface RemoveRelatedOptions<S = Record<string, any>> {
-  service: keyof S
-  keyThere: string
-  keyHere: string
-  blocking?: boolean
-}
-
-export interface CreateRelatedOptions<S = Record<string, any>> {
-  service: keyof S
-  multi?: boolean
-  data: (item: any, context: HookContext) => Promisable<Record<string, any>>
-  createItemsInDataArraySeparately?: boolean
-}
-
-export type OnDeleteAction = "cascade" | "set null";
-
-export interface OnDeleteOptions {
-    keyThere: string
-    keyHere: string
-    onDelete: OnDeleteAction
-    blocking?: boolean
-}
-
-//#endregion
-
-//#region mixins
-
-export interface InitDebounceMixinOptions {
-  default: Partial<DebouncedStoreOptions>
-  blacklist: string[]
-  [key: string]: unknown
-}
-
-export type DebouncedFunctionApp = (app?: Application) => void | Promise<void>;
-
-export interface DebouncedStoreOptions {
-  leading: boolean
-  maxWait: number | undefined
-  trailing: boolean
-  wait: number
-}
-
-/*interface WaitingObject {
-    id: Id,
-    action: FunctionApp
-}*/
-
-//#endregion
-
-//#region utils
-export interface PushSetOptions {
-  unique?: boolean
-}
-
-export 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?: AdapterBase<T>
-  operators?: PlainFilterQueryOptions["operators"],
-  filters?: PlainFilterQueryOptions["filters"],
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface GetItemsIsArrayOptions<T = any> {
-  items: T[]
-  isArray: boolean
-}
-
-//#endregion
+export type PredicateWithContext<T = any> = (
+  item: T,
+  context: HookContext
+) => boolean;

package/src/typesInternal.ts

@@ -0,0 +1,6 @@
+// here are types that are not meant to be exported!
+// just for internal use of this package
+
+export type MaybeArray<T> = T | T[];
+export type Promisable<T> = T | Promise<T>;
+export type Path = Array<string | number>;

package/src/utils/filterQuery.ts

@@ -1,30 +1,42 @@
-import { 
-  filterQuery as plainFilterQuery,
-} from "@feathersjs/adapter-commons";
+import { filterQuery as plainFilterQuery } from "@feathersjs/adapter-commons";
 
 import type {
   FilterQueryOptions as PlainFilterQueryOptions,
+  AdapterBase,
 } from "@feathersjs/adapter-commons";
 
 import type { Query } from "@feathersjs/feathers";
-import type { FilterQueryOptions } from "../types";
+
+export interface FilterQueryOptions<T> {
+  service?: AdapterBase<T>;
+  operators?: PlainFilterQueryOptions["operators"];
+  filters?: PlainFilterQueryOptions["filters"];
+}
 
 export function filterQuery<T>(query: Query, _options?: FilterQueryOptions<T>) {
   query = query || {};
   _options = _options || {};
   const { service, ...options } = _options;
   if (service) {
-    const operators = options.operators 
+    const operators = options.operators
       ? options.operators
       : service.options?.operators;
     const filters = options.filters
       ? options.filters
       : service.options?.filters;
-    const optionsForFilterQuery: PlainFilterQueryOptions = {}; 
-    if (operators) { optionsForFilterQuery.operators = operators; }
-    if (filters) { optionsForFilterQuery.filters = filters; }
-    // @ts-expect-error service has no filterQuery method
-    if (service && "filterQuery" in service && typeof service.filterQuery === "function") {
+    const optionsForFilterQuery: PlainFilterQueryOptions = {};
+    if (operators) {
+      optionsForFilterQuery.operators = operators;
+    }
+    if (filters) {
+      optionsForFilterQuery.filters = filters;
+    }
+    if (
+      service &&
+      "filterQuery" in service &&
+      // @ts-expect-error service is of type 'never'
+      typeof service.filterQuery === "function"
+    ) {
       // @ts-expect-error service has no filterQuery method
       return service.filterQuery({ query }, optionsForFilterQuery);
     } else {

package/src/utils/getItemsIsArray.ts

@@ -1,23 +1,22 @@
 import type { HookContext } from "@feathersjs/feathers";
-import type { GetItemsIsArrayOptions } from "..";
+
+export interface GetItemsIsArrayOptions<T = any> {
+  items: T[];
+  isArray: boolean;
+}
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const getItemsIsArray = <T = any>(
-  context: HookContext
+export const getItemsIsArray = <T = any, H extends HookContext = HookContext>(
+  context: H
 ): GetItemsIsArrayOptions<T> => {
-  let itemOrItems = context.type === "before" 
-    ? context.data 
-    : context.result;
-  itemOrItems = itemOrItems && context.method === "find" 
-    ? (itemOrItems.data || itemOrItems) 
-    : itemOrItems;
+  let itemOrItems = context.type === "before" ? context.data : context.result;
+  itemOrItems =
+    itemOrItems && context.method === "find"
+      ? itemOrItems.data || itemOrItems
+      : itemOrItems;
   const isArray = Array.isArray(itemOrItems);
   return {
-    items: (isArray) 
-      ? itemOrItems 
-      : (itemOrItems != null) 
-        ? [itemOrItems] 
-        : [],
-    isArray
+    items: isArray ? itemOrItems : itemOrItems != null ? [itemOrItems] : [],
+    isArray,
   };
-};
+};

package/src/utils/getPaginate.ts

@@ -1,25 +1,22 @@
+import type { PaginationOptions } from "@feathersjs/adapter-commons";
 import type { HookContext } from "@feathersjs/feathers";
 
-// TODO: seems like this does no longer exist in feathers
-interface PaginationOptions {
-  default: number;
-  max: number;
-}
-
-export const getPaginate = (
-  context: HookContext
+export const getPaginate = <H extends HookContext = HookContext>(
+  context: H
 ): PaginationOptions | undefined => {
   if (Object.prototype.hasOwnProperty.call(context.params, "paginate")) {
-    return context.params.paginate as PaginationOptions || undefined;
+    return (context.params.paginate as PaginationOptions) || undefined;
+  }
+
+  if (context.params.paginate === false) {
+    return undefined;
   }
-  
-  if (context.params.paginate === false) { return undefined; }
   let options = context.service.options || {};
-  
+
   options = {
     ...options,
-    ...context.params.adapter
+    ...context.params.adapter,
   };
-  
+
   return options.paginate || undefined;
 };

package/src/utils/isMulti.ts

@@ -1,7 +1,7 @@
 import type { HookContext } from "@feathersjs/feathers";
 
-export const isMulti = (
-  context: HookContext
+export const isMulti = <H extends HookContext = HookContext>(
+  context: H
 ): boolean => {
   const { method } = context;
   if (method === "find") {
@@ -15,4 +15,4 @@ export const isMulti = (
     return false;
   }
   return false;
-};
+};