feathers-utils 2.0.0-0 → 2.0.0-2

package/src/hooks/setData.ts

@@ -1,17 +1,17 @@
-import _get from "lodash/get";
-import _set from "lodash/set";
-import _has from "lodash/has";
-
-import { getItems } from "feathers-hooks-common";
+import _get from "lodash/get.js";
+import _set from "lodash/set.js";
+import _has from "lodash/has.js";
 
 import { Forbidden } from "@feathersjs/errors";
+import { getItemsIsArray } from "../utils/getItemsIsArray";
 
 import type { HookContext } from "@feathersjs/feathers";
+import type { PropertyPath } from "lodash";
 
 import type {
-  HookSetDataOptions
+  HookSetDataOptions, 
+  ReturnSyncHook 
 } from "../types";
-import type { PropertyPath } from "lodash";
 
 const defaultOptions: Required<HookSetDataOptions> = {
   allowUndefined: false,
@@ -22,13 +22,11 @@ export function setData(
   from: PropertyPath, 
   to: PropertyPath, 
   _options?: HookSetDataOptions
-): ((context: HookContext) => HookContext) {
+): ReturnSyncHook {
   const options: Required<HookSetDataOptions> = Object.assign({}, defaultOptions, _options);
   return (context: HookContext): HookContext => {
 
-    //@ts-expect-error type error because feathers-hooks-common is feathers@4
-    let items = getItems(context);
-    items = (Array.isArray(items)) ? items : [items];
+    const { items } = getItemsIsArray(context);
 
     if (!_has(context, from)) {
       if (!context.params?.provider || options.allowUndefined === true) {
@@ -45,7 +43,14 @@ export function setData(
     const val = _get(context, from);
 
     items.forEach((item: Record<string, unknown>) => {
-      if (!options.overwrite && _has(item, to)) { return; }
+      let overwrite: boolean;
+      if (typeof options.overwrite === "function") {
+        overwrite = options.overwrite(item, context);
+      } else {
+        overwrite = options.overwrite;
+      }
+
+      if (!overwrite && _has(item, to)) { return; }
 
       _set(item, to, val);
     });

package/src/index.ts

@@ -1,6 +1,7 @@
 // hooks
 import { checkMulti } from "./hooks/checkMulti";
 import { setData } from "./hooks/setData";
+
 import { runPerItem } from "./hooks/runPerItem";
 
 export const hooks = {
@@ -10,7 +11,9 @@ export const hooks = {
 };
 
 export { checkMulti };
+export { createRelated } from "./hooks/createRelated";
 export { setData };
+export { removeRelated } from "./hooks/removeRelated";
 export { runPerItem };
 
 import { debounceMixin, DebouncedService, DebouncedStore } from "./mixins/debounce-mixin";
@@ -33,8 +36,15 @@ 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 { filterQuery } from "./utils/filterQuery";
+export { validateQueryProperty } from "./utils/validateQueryProperty";
+
+
+// query filters
+export { filterArray } from "./filters/array";
 
 export * from "./types";

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

@@ -1,4 +1,4 @@
-import _debounce from "lodash/debounce";
+import _debounce from "lodash/debounce.js";
 
 import type { DebouncedFunc } from "lodash";
 import type { Application, Id } from "@feathersjs/feathers";
@@ -18,58 +18,58 @@ export const makeDefaultOptions = (): DebouncedStoreOptions => {
 };
 
 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>)>>;
-    //_waitingById: Record<string, WaitingObject>;
-    add;
-    constructor(app: Application, options?: Partial<DebouncedStoreOptions>) {
-      this._app = app;
-      this._options = Object.assign(makeDefaultOptions(), options);
-      this._queueById = {};
-      this._isRunningById = {};
-      //this._waitingById = {};
+  private _app: Application;
+  private _options: DebouncedStoreOptions;
+  private _isRunningById: Record<string, unknown>;
+  _queueById: Record<string, DebouncedFunc<((id: Id, action: DebouncedFunctionApp) => void | Promise<void>)>>;
+  //_waitingById: Record<string, WaitingObject>;
+  add;
+  constructor(app: Application, options?: Partial<DebouncedStoreOptions>) {
+    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
-        }
-      );
-    }
-
-    private async unbounced(id: Id, action: DebouncedFunctionApp): Promise<void> {
-      if (this._queueById[id] === undefined) {
-        return;
+    this.add = this.debounceById(
+      this.unbounced, 
+      this._options.wait, 
+      {
+        leading: this._options.leading,
+        maxWait: this._options.maxWait,
+        trailing: this._options.trailing
       }
-      delete this._queueById[id];
-      this._isRunningById[id] = true;
-      await action(this._app);
-      delete this._isRunningById[id];
+    );
+  }
+
+  private async unbounced(id: Id, action: DebouncedFunctionApp): Promise<void> {
+    if (this._queueById[id] === undefined) {
+      return;
     }
+    delete this._queueById[id];
+    this._isRunningById[id] = true;
+    await action(this._app);
+    delete this._isRunningById[id];
+  }
 
-    private debounceById(
-      func: ((id: Id, action: DebouncedFunctionApp) => Promise<void>), 
-      wait: number, 
-      options?: Partial<DebouncedStoreOptions>
-    ) {
-      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
+  private debounceById(
+    func: ((id: Id, action: DebouncedFunctionApp) => Promise<void>), 
+    wait: number, 
+    options?: Partial<DebouncedStoreOptions>
+  ) {
+    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
+      return this._queueById[id](id, action);
+    };
+  }
 
-    cancel(id: Id): void {
-      delete this._queueById[id];
-    }
+  cancel(id: Id): void {
+    delete this._queueById[id];
+  }
 }

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

@@ -11,14 +11,17 @@ import type {
 } from "../../types";
 
 export type DebouncedService = FeathersService & {
-  debouncedStore?: DebouncedStore;
+  debouncedStore: DebouncedStore;
 };
 
-export function debounceMixin(options?: Partial<InitDebounceMixinOptions>): ((app: Application) => void) {
+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: DebouncedService, path) => {
+    
+    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`

package/src/types.ts

@@ -1,18 +1,31 @@
-import type { Application } from "@feathersjs/feathers";
-import type { AdapterService } from "@feathersjs/adapter-commons";
+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";
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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
+  overwrite?: boolean | PredicateWithContext
 }
 
 export interface AddHookOptions {
@@ -27,6 +40,29 @@ 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
@@ -70,21 +106,15 @@ export interface MergeQueryOptions<T> extends FilterQueryOptions<T> {
 }
 
 export interface FilterQueryOptions<T> {
-  service?: AdapterService<T>
-  operators?: string[],
-  filters?: string[],
+  service?: AdapterBase<T>
+  operators?: PlainFilterQueryOptions["operators"],
+  filters?: PlainFilterQueryOptions["filters"],
 }
 
-export interface PlainFilterQueryOptions {
-  operators?: string[],
-  filters?: string[],
-}
-
-export interface FilterQueryResult {
-  filters: Record<string, unknown>
-  query: Record<string, unknown>
-  paginate?: unknown
-  [key: string]: unknown
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface GetItemsIsArrayOptions<T = any> {
+  items: T[]
+  isArray: boolean
 }
 
 //#endregion

package/src/utils/filterQuery.ts

@@ -1,34 +1,35 @@
 import { 
-  filterQuery as plainFilterQuery
+  filterQuery as plainFilterQuery,
 } from "@feathersjs/adapter-commons";
 
 import type {
-  FilterQueryOptions,
-  FilterQueryResult,
-  PlainFilterQueryOptions
-} from "../types";
+  FilterQueryOptions as PlainFilterQueryOptions,
+} from "@feathersjs/adapter-commons";
 
 import type { Query } from "@feathersjs/feathers";
+import type { FilterQueryOptions } from "../types";
 
-export function filterQuery<T>(query: Query, options?: FilterQueryOptions<T>): FilterQueryResult {
+export function filterQuery<T>(query: Query, _options?: FilterQueryOptions<T>) {
   query = query || {};
-  options = options || {};
-  if (options?.service) {
-    const { service } = options;
+  _options = _options || {};
+  const { service, ...options } = _options;
+  if (service) {
     const operators = options.operators 
       ? options.operators
-      : service.options?.whitelist;
+      : 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; }
-    if (typeof service?.filterQuery === "function") {
-      return service.filterQuery({ query }, optionsForFilterQuery) as FilterQueryResult;
+    // @ts-expect-error service has no filterQuery method
+    if (service && "filterQuery" in service && typeof service.filterQuery === "function") {
+      // @ts-expect-error service has no filterQuery method
+      return service.filterQuery({ query }, optionsForFilterQuery);
     } else {
-      return plainFilterQuery(query, optionsForFilterQuery) as FilterQueryResult;
+      return plainFilterQuery(query, optionsForFilterQuery);
     }
   }
-  return plainFilterQuery(query, options) as FilterQueryResult;
+  return plainFilterQuery(query, options);
 }

package/src/utils/getItemsIsArray.ts

@@ -0,0 +1,23 @@
+import type { HookContext } from "@feathersjs/feathers";
+import type { GetItemsIsArrayOptions } from "..";
+
+// 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;
+  const isArray = Array.isArray(itemOrItems);
+  return {
+    items: (isArray) 
+      ? itemOrItems 
+      : (itemOrItems != null) 
+        ? [itemOrItems] 
+        : [],
+    isArray
+  };
+};

package/src/utils/getPaginate.ts

@@ -1,4 +1,4 @@
-import { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from "@feathersjs/feathers";
 
 // TODO: seems like this does no longer exist in feathers
 interface PaginationOptions {
@@ -6,7 +6,6 @@ interface PaginationOptions {
   max: number;
 }
 
-
 export const getPaginate = (
   context: HookContext
 ): PaginationOptions | undefined => {

package/src/utils/isMulti.ts

@@ -1,6 +1,8 @@
 import type { HookContext } from "@feathersjs/feathers";
 
-export const isMulti = (context: HookContext): boolean => {
+export const isMulti = (
+  context: HookContext
+): boolean => {
   const { method } = context;
   if (method === "find") {
     return true;

package/src/utils/isPaginated.ts

@@ -1,4 +1,4 @@
-import { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from "@feathersjs/feathers";
 import { getPaginate } from "./getPaginate";
 
 export const isPaginated = (

package/src/utils/markHookForSkip.ts

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

package/src/utils/mergeQuery/index.ts

@@ -1,10 +1,10 @@
-import _get from "lodash/get";
-import _has from "lodash/has";
-import _isEmpty from "lodash/isEmpty";
-import _isEqual from "lodash/isEqual";
-import _merge from "lodash/merge";
-import _set from "lodash/set";
-import _uniqWith from "lodash/uniqWith";
+import _get from "lodash/get.js";
+import _has from "lodash/has.js";
+import _isEmpty from "lodash/isEmpty.js";
+import _isEqual from "lodash/isEqual.js";
+import _merge from "lodash/merge.js";
+import _set from "lodash/set.js";
+import _uniqWith from "lodash/uniqWith.js";
 
 import { mergeArrays } from "./mergeArrays";
 import { filterQuery } from "../filterQuery";
@@ -249,6 +249,12 @@ function makeDefaultOptions<T>(options?: Partial<MergeQueryOptions<T>>): MergeQu
   return options as MergeQueryOptions<T>;
 }
 
+function moveProperty(source: Record<string, any>, target: Record<string, any>, key: string): void {
+  if (!Object.prototype.hasOwnProperty.call(source, key)) { return; }
+  target[key] = source[key];
+  delete source[key];
+}
+
 export function mergeQuery<T>(target: Query, source: Query, options?: Partial<MergeQueryOptions<T>>): Query {
   const fullOptions = makeDefaultOptions(options);
   const {
@@ -259,9 +265,12 @@ export function mergeQuery<T>(target: Query, source: Query, options?: Partial<Me
     service: fullOptions.service 
   });
 
+  moveProperty(targetFilters, targetQuery, "$or");
+  moveProperty(targetFilters, targetQuery, "$and");
+
   if (target.$limit) { targetFilters.$limit = target.$limit; }
   
-  let { 
+  let {
     // eslint-disable-next-line prefer-const
     filters: sourceFilters, 
     query: sourceQuery 
@@ -270,6 +279,9 @@ export function mergeQuery<T>(target: Query, source: Query, options?: Partial<Me
     service: fullOptions.service 
   });
 
+  moveProperty(sourceFilters, sourceQuery, "$or");
+  moveProperty(sourceFilters, sourceQuery, "$and");
+
   if (source.$limit) { sourceFilters.$limit = source.$limit; }
 
   //#region filters

package/src/utils/pushSet.ts

@@ -1,6 +1,6 @@
-import _isEqual from "lodash/isEqual";
-import _get from "lodash/get";
-import _set from "lodash/set";
+import _isEqual from "lodash/isEqual.js";
+import _get from "lodash/get.js";
+import _set from "lodash/set.js";
 
 import type {
   Path,

package/src/utils/setResultEmpty.ts

@@ -1,4 +1,4 @@
-import { HookContext } from "@feathersjs/feathers";
+import type { HookContext } from "@feathersjs/feathers";
 import { isMulti } from "..";
 import { isPaginated } from "./isPaginated";
 

package/src/utils/shouldSkip.ts

@@ -5,7 +5,10 @@ import { GeneralError } from "@feathersjs/errors";
 
 import type { HookContext } from "@feathersjs/feathers";
 
-export const shouldSkip = (hookName: string, context: HookContext): boolean => {
+export const shouldSkip = (
+  hookName: string, 
+  context: HookContext
+): boolean => {
   if (!context.params || !context.params.skipHooks) {
     return false;
   }

package/src/utils/validateQueryProperty.ts

@@ -0,0 +1,27 @@
+import { _ } from "@feathersjs/commons";
+import { BadRequest } from "@feathersjs/errors";
+import type { Query } from "@feathersjs/feathers";
+
+const isPlainObject = (value: any) => _.isObject(value) && value.constructor === {}.constructor;
+
+export const validateQueryProperty = (query: any, operators: string[] = []): Query => {
+  if (!isPlainObject(query)) {
+    return query;
+  }
+
+  for (const key of Object.keys(query)) {
+    if (key.startsWith("$") && !operators.includes(key)) {
+      throw new BadRequest(`Invalid query parameter ${key}`, query);
+    }
+
+    const value = query[key];
+
+    if (isPlainObject(value)) {
+      query[key] = validateQueryProperty(value, operators);
+    }
+  }
+
+  return {
+    ...query
+  };
+};

package/.eslintignore

@@ -1,3 +0,0 @@
-node_modules
-dist
-coverage

package/.eslintrc.js

@@ -1,44 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    node: true,
-    mocha: true
-  },
-  parser: "@typescript-eslint/parser",
-  plugins: [
-    "security",
-    "@typescript-eslint"
-  ],
-  extends: [
-    "eslint:recommended",
-    "plugin:security/recommended",
-    "plugin:@typescript-eslint/recommended"
-  ],
-  rules: {
-    "quotes": ["warn", "double", "avoid-escape"],
-    "indent": ["warn", 2, { "SwitchCase": 1 }],
-    "semi": ["warn", "always"],
-    "@typescript-eslint/no-unused-vars": "warn",
-    "no-console": "off",
-    "camelcase": "warn",
-    "require-atomic-updates": "off",
-    "prefer-destructuring": ["warn", {
-      "array": false,
-      "object": true
-    }, {
-      "enforceForRenamedProperties": false
-    }],
-    "security/detect-object-injection": "off",
-    "object-curly-spacing": ["warn", "always"],
-    "prefer-const": ["warn"]
-  },
-  overrides: [
-    {
-      "files": ["test/**/*.ts"],
-      "rules": {
-        "@typescript-eslint/ban-ts-comment": ["off"]
-      }
-    }
-  ]
-};
-  

package/.gitlab-ci.yml

@@ -1,11 +0,0 @@
-.feathers-utils:
-  only:
-    changes:
-      - packages/feathers-utils/**/*
-
-test:feathers-utils:
-  variables:
-    DIR: packages/feathers-utils
-  extends:
-    - .feathers-utils
-    - .test

package/.mocharc.js

@@ -1,11 +0,0 @@
-'use strict';
-const path = require("path");
-
-module.exports = {
-  extension: ["ts"],
-  package: path.join(__dirname, "./package.json"),
-  ui: "bdd",
-  spec: [
-    "./test/**/*.test.ts",
-  ]
-};

package/.nycrc.json

@@ -1,22 +0,0 @@
-{
-  "extends": "@istanbuljs/nyc-config-typescript",
-  "cache": false,
-  "check-coverage": false,
-  "include": [
-    "src/**/*.js",
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "src/types.ts",
-    "src/index.ts"
-  ],
-  "reporter": [
-    "html",
-    "text",
-    "text-summary",
-    "lcov"
-  ],
-  "sourceMap": true,
-  "all": true,
-  "instrument": true
-}

package/index.js

@@ -1,9 +0,0 @@
-exports.mergeQuery = require("./src/mergeQuery");
-exports.mergeArrays = require("./src/mergeQuery/mergeArrays");
-exports.shouldSkip = require("./src/shouldSkip");
-exports.pushSet = require("./src/pushSet");
-exports.isMulti = require("./src/isMulti");
-
-exports.hooks = {
-  checkMulti: require("./src/hooks/checkMulti")
-};