feathers-utils 6.0.0 → 7.0.1

package/src/index.ts

@@ -1,8 +1,8 @@
-export * from "./hooks";
-export * from "./mixins";
+export * from './hooks/index.js'
+export * from './mixins/index.js'
 
-export * from "./utils";
-export * from "./filters";
+export * from './utils/index.js'
+export * from './filters/index.js'
 
-export * from "./types";
-export * from "./utility-types";
+export * from './types.js'
+export * from './utility-types/index.js'

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

@@ -1,48 +1,48 @@
-import _debounce from "lodash/debounce.js";
+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 { makeDefaultOptions } from "./utils";
+import type { DebouncedFunc } from 'lodash'
+import type { Application, Id } from '@feathersjs/feathers'
+import type { DebouncedFunctionApp, DebouncedStoreOptions } from './types.js'
+import { makeDefaultOptions } from './utils.js'
 
 export type DebouncedService<T = any> = T & {
-  debouncedStore: DebouncedStore;
-};
+  debouncedStore: DebouncedStore
+}
 
 export class DebouncedStore {
-  private _app: Application;
-  private _options: DebouncedStoreOptions;
-  private _isRunningById: Record<string, unknown>;
+  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;
+  add
   constructor(app: Application, options?: Partial<DebouncedStoreOptions>) {
-    this._app = app;
-    this._options = Object.assign(makeDefaultOptions(), options);
-    this._queueById = {};
-    this._isRunningById = {};
+    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;
+      return
     }
-    delete this._queueById[id];
-    this._isRunningById[id] = true;
-    await action(this._app);
-    delete this._isRunningById[id];
+    delete this._queueById[id]
+    this._isRunningById[id] = true
+    await action(this._app)
+    delete this._isRunningById[id]
   }
 
   private debounceById(
@@ -51,22 +51,22 @@ export class DebouncedStore {
     options?: Partial<DebouncedStoreOptions>,
   ) {
     return (id: Id, action: (app?: Application) => void | Promise<void>) => {
-      if (typeof this._queueById[id] === "function") {
-        return this._queueById[id](id, action);
+      if (typeof this._queueById[id] === 'function') {
+        return this._queueById[id](id, action)
       }
 
       this._queueById[id] = _debounce(
         (id, action) => {
-          this.unbounced(id, action);
+          this.unbounced(id, action)
         },
         wait,
         { ...options, leading: false },
-      ); // leading required for return promise
-      return this._queueById[id](id, action);
-    };
+      ) // leading required for return promise
+      return this._queueById[id](id, action)
+    }
   }
 
   cancel(id: Id): void {
-    delete this._queueById[id];
+    delete this._queueById[id]
   }
 }

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

@@ -1,34 +1,34 @@
-import type { Application } from "@feathersjs/feathers/lib";
-import { DebouncedStore } from "./DebouncedStore";
-import type { DebouncedStoreOptions, InitDebounceMixinOptions } from "./types";
-import { makeDefaultOptions } from "./utils";
+import type { Application } from '@feathersjs/feathers'
+import { DebouncedStore } from './DebouncedStore.js'
+import type {
+  DebouncedStoreOptions,
+  InitDebounceMixinOptions,
+} from './types.js'
+import { makeDefaultOptions } from './utils.js'
 
 export function debounceMixin(
   options?: Partial<InitDebounceMixinOptions>,
 ): (app: Application) => void {
   return (app: Application): void => {
-    options = options || {};
-    const defaultOptions = Object.assign(
-      makeDefaultOptions(),
-      options?.default,
-    );
+    options = options || {}
+    const defaultOptions = Object.assign(makeDefaultOptions(), options?.default)
 
-    app.mixins.push((service: any, path) => {
+    app.mixins.push((service: any, path: string) => {
       // if path is on blacklist, don't add debouncedStore to service
-      if (options?.blacklist && options.blacklist.includes(path)) return;
+      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;
+        )
+        return
       }
 
-      const serviceOptions = Object.assign({}, defaultOptions, options?.[path]);
+      const serviceOptions = Object.assign({}, defaultOptions, options?.[path])
       service.debouncedStore = new DebouncedStore(
         app,
         serviceOptions as DebouncedStoreOptions,
-      );
-    });
-  };
+      )
+    })
+  }
 }

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

@@ -1,3 +1,3 @@
-export * from "./types";
-export * from "./DebouncedStore";
-export * from "./debounceMixin";
+export * from './types.js'
+export * from './DebouncedStore.js'
+export * from './debounceMixin.js'

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

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

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

@@ -1,4 +1,4 @@
-import type { DebouncedStoreOptions } from "./types";
+import type { DebouncedStoreOptions } from './types.js'
 
 export const makeDefaultOptions = (): DebouncedStoreOptions => {
   return {
@@ -6,5 +6,5 @@ export const makeDefaultOptions = (): DebouncedStoreOptions => {
     maxWait: undefined,
     trailing: true,
     wait: 100,
-  };
-};
+  }
+}

package/src/mixins/index.ts

@@ -1 +1 @@
-export * from "./debounce-mixin";
+export * from './debounce-mixin/index.js'

package/src/types.ts

@@ -1,10 +1,8 @@
-import type { HookContext } from "@feathersjs/feathers";
+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;
+) => boolean

package/src/typesInternal.ts

@@ -1,26 +1,26 @@
 // here are types that are not meant to be exported!
 // just for internal use of this package
 
-import type { HookContext } from "@feathersjs/feathers/lib";
+import type { HookContext } from '@feathersjs/feathers'
 
-export type MaybeArray<T> = T | T[];
-export type Promisable<T> = T | Promise<T>;
-export type Path = Array<string | number>;
+export type MaybeArray<T> = T | T[]
+export type Promisable<T> = T | Promise<T>
+export type Path = Array<string | number>
 
-export type HookType = "before" | "after" | "error";
+export type HookType = 'before' | 'after' | 'error'
 export type ServiceMethodName =
-  | "find"
-  | "get"
-  | "create"
-  | "update"
-  | "patch"
-  | "remove";
+  | 'find'
+  | 'get'
+  | 'create'
+  | 'update'
+  | 'patch'
+  | 'remove'
 
 export type ReturnSyncHook<H extends HookContext = HookContext> = (
   context: H,
-) => H;
+) => H
 export type ReturnAsyncHook<H extends HookContext = HookContext> = (
   context: H,
-) => Promise<H>;
+) => Promise<H>
 
-export type KeyOf<T> = Extract<keyof T, string>;
+export type KeyOf<T> = Extract<keyof T, string>

package/src/utility-types/index.ts

@@ -1,162 +1,162 @@
-import type { Application, Id } from "@feathersjs/feathers";
+import type { Application, Id } from '@feathersjs/feathers'
 
-type Single<T> = T extends Array<infer U> ? U : T;
-type AsArray<T> = T extends any[] ? T : [T];
+type Single<T> = T extends Array<infer U> ? U : T
+type AsArray<T> = T extends any[] ? T : [T]
 
 export type InferCreateData<S> = S extends {
-  create: (data: infer D, params: any) => any;
+  create: (data: infer D, params: any) => any
 }
   ? D
-  : never;
+  : never
 
-export type InferCreateDataSingle<S> = Single<InferCreateData<S>>;
+export type InferCreateDataSingle<S> = Single<InferCreateData<S>>
 
 export type InferUpdateData<S> = S extends {
-  update: (id: any, data: infer D, params: any) => any;
+  update: (id: any, data: infer D, params: any) => any
 }
   ? D
-  : never;
+  : never
 
 export type InferPatchData<S> = S extends {
-  patch: (id: any, data: infer D, params: any) => any;
+  patch: (id: any, data: infer D, params: any) => any
 }
   ? D
-  : never;
+  : never
 
 export type InferGetResult<S> = S extends {
-  get: (id: any, params: any) => infer R;
+  get: (id: any, params: any) => infer R
 }
   ? Awaited<R>
-  : never;
+  : never
 
 export type InferFindResult<S> = S extends {
-  find: (params: any) => infer R;
+  find: (params: any) => infer R
 }
   ? Awaited<R>
-  : never;
+  : never
 
 export type InferCreateResult<S, D = unknown> = S extends {
-  create: (data: any, params: any) => infer R;
+  create: (data: any, params: any) => infer R
 }
   ? D extends any[]
     ? AsArray<Awaited<R>>
     : D extends InferCreateDataSingle<S>
       ? Single<Awaited<R>>
       : Awaited<R>
-  : never;
+  : never
 
-export type InferCreateResultSingle<S> = Single<InferCreateResult<S>>;
+export type InferCreateResultSingle<S> = Single<InferCreateResult<S>>
 
 export type InferUpdateResult<S> = S extends {
-  update: (id: any, data: any, params: any) => infer R;
+  update: (id: any, data: any, params: any) => infer R
 }
   ? Awaited<R>
-  : never;
+  : never
 
 export type InferPatchResult<S, IdOrNullable = any> = S extends {
-  patch: (id: Id, data: any, params: any) => infer R;
+  patch: (id: Id, data: any, params: any) => infer R
 }
   ? IdOrNullable extends Id
     ? Single<Awaited<R>>
     : IdOrNullable extends null
       ? AsArray<Awaited<R>>
       : Awaited<R>
-  : never;
+  : never
 
 export type InferRemoveResult<S, IdOrNullable = any> = S extends {
-  remove: (id: IdOrNullable, params: any) => infer R;
+  remove: (id: IdOrNullable, params: any) => infer R
 }
   ? IdOrNullable extends Id
     ? Single<Awaited<R>>
     : IdOrNullable extends null
       ? AsArray<Awaited<R>>
       : Awaited<R>
-  : never;
+  : never
 
 export type GetService<
   App extends Application,
   Path extends string,
-> = App["services"][Path];
+> = App['services'][Path]
 
 export type InferGetResultFromPath<
   App extends Application,
   Path extends string,
-> = InferGetResult<GetService<App, Path>>;
+> = InferGetResult<GetService<App, Path>>
 export type InferFindResultFromPath<
   App extends Application,
   Path extends string,
-> = InferFindResult<GetService<App, Path>>;
+> = InferFindResult<GetService<App, Path>>
 
 export type InferCreateDataFromPath<
   App extends Application,
   Path extends string,
-> = InferCreateData<GetService<App, Path>>;
+> = InferCreateData<GetService<App, Path>>
 export type InferCreateDataSingleFromPath<
   App extends Application,
   Path extends string,
-> = InferCreateDataSingle<GetService<App, Path>>;
+> = InferCreateDataSingle<GetService<App, Path>>
 
 export type InferCreateResultFromPath<
   App extends Application,
   Path extends string,
   D = unknown,
-> = InferCreateResult<GetService<App, Path>, D>;
+> = InferCreateResult<GetService<App, Path>, D>
 export type InferCreateResultSingleFromPath<
   App extends Application,
   Path extends string,
-> = InferCreateResultSingle<GetService<App, Path>>;
+> = InferCreateResultSingle<GetService<App, Path>>
 
 export type InferUpdateDataFromPath<
   App extends Application,
   Path extends string,
-> = InferUpdateData<GetService<App, Path>>;
+> = InferUpdateData<GetService<App, Path>>
 export type InferPatchDataFromPath<
   App extends Application,
   Path extends string,
-> = InferPatchData<GetService<App, Path>>;
+> = InferPatchData<GetService<App, Path>>
 
 export type InferUpdateResultFromPath<
   App extends Application,
   Path extends string,
-> = InferUpdateResult<GetService<App, Path>>;
+> = InferUpdateResult<GetService<App, Path>>
 export type InferPatchResultFromPath<
   App extends Application,
   Path extends string,
   IdOrNullable = any,
-> = InferPatchResult<GetService<App, Path>, IdOrNullable>;
+> = InferPatchResult<GetService<App, Path>, IdOrNullable>
 
 export type InferRemoveResultFromPath<
   App extends Application,
   Path extends string,
   IdOrNullable = any,
-> = InferRemoveResult<GetService<App, Path>, IdOrNullable>;
+> = InferRemoveResult<GetService<App, Path>, IdOrNullable>
 
 export type InferDataFromPath<
   App extends Application,
   Path extends string,
-  Method extends "create" | "update" | "patch",
-> = Method extends "create"
+  Method extends 'create' | 'update' | 'patch',
+> = Method extends 'create'
   ? InferCreateDataFromPath<App, Path>
-  : Method extends "update"
+  : Method extends 'update'
     ? InferUpdateDataFromPath<App, Path>
-    : Method extends "patch"
+    : Method extends 'patch'
       ? InferPatchDataFromPath<App, Path>
-      : never;
+      : never
 
 export type InferResultFromPath<
   App extends Application,
   Path extends string,
-  Method extends "get" | "find" | "create" | "update" | "patch" | "remove",
-> = Method extends "get"
+  Method extends 'get' | 'find' | 'create' | 'update' | 'patch' | 'remove',
+> = Method extends 'get'
   ? InferGetResultFromPath<App, Path>
-  : Method extends "find"
+  : Method extends 'find'
     ? InferFindResultFromPath<App, Path>
-    : Method extends "create"
+    : Method extends 'create'
       ? InferCreateResultFromPath<App, Path>
-      : Method extends "update"
+      : Method extends 'update'
         ? InferUpdateResultFromPath<App, Path>
-        : Method extends "patch"
+        : Method extends 'patch'
           ? InferPatchResultFromPath<App, Path>
-          : Method extends "remove"
+          : Method extends 'remove'
             ? InferRemoveResultFromPath<App, Path>
-            : never;
+            : never

package/src/utils/_utils.internal.ts

@@ -2,15 +2,15 @@ export const hasOwnProperty = (
   obj: Record<string, unknown>,
   ...keys: string[]
 ): boolean => {
-  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x));
-};
+  return keys.some((x) => Object.prototype.hasOwnProperty.call(obj, x))
+}
 
 export const isObject = (item: unknown): boolean =>
-  !!item && typeof item === "object" && !Array.isArray(item);
+  !!item && typeof item === 'object' && !Array.isArray(item)
 
 export const isPlainObject = (value: unknown): boolean =>
-  isObject(value) && value.constructor === {}.constructor;
+  isObject(value) && value.constructor === {}.constructor
 
 export const isEmpty = (obj: unknown): boolean =>
   [Object, Array].includes((obj || {}).constructor as any) &&
-  !Object.keys(obj || {}).length;
+  !Object.keys(obj || {}).length

package/src/utils/defineHooks.ts

@@ -1,16 +1,16 @@
-import type { Application, HookOptions } from "@feathersjs/feathers";
+import type { Application, HookOptions } from '@feathersjs/feathers'
 
 export function defineHooks<
   A extends Application = Application,
   S = {
-    find: any;
-    get: any;
-    create: any;
-    update: any;
-    patch: any;
-    remove: any;
+    find: any
+    get: any
+    create: any
+    update: any
+    patch: any
+    remove: any
   },
   Options = HookOptions<A, S>,
 >(hooks: Options): Options {
-  return hooks;
+  return hooks
 }

package/src/utils/deflattenQuery.ts

@@ -1,40 +1,40 @@
-import type { Query } from "@feathersjs/feathers";
-import _set from "lodash/set.js";
-import { isObject } from "./_utils.internal";
+import type { Query } from '@feathersjs/feathers'
+import _set from 'lodash/set.js'
+import { isObject } from './_utils.internal.js'
 
 export function deflattenQuery(query: Query) {
-  const result: Query = {};
+  const result: Query = {}
 
   Object.keys(query).forEach((key) => {
-    const value = query[key];
+    const value = query[key]
 
     if (Array.isArray(value)) {
-      _set(result, key, value.map(deflattenQuery));
-      return;
+      _set(result, key, value.map(deflattenQuery))
+      return
     }
 
     if (isObject(value)) {
-      _set(result, key, deflattenQuery(value));
-      return;
+      _set(result, key, deflattenQuery(value))
+      return
     }
 
-    _set(result, key, query[key]);
-  });
+    _set(result, key, query[key])
+  })
 
-  return result;
+  return result
 }
 
 if (import.meta.vitest) {
-  const { describe, it, expect } = import.meta.vitest;
+  const { describe, it, expect } = import.meta.vitest
 
-  describe("deflattenQuery", () => {
-    it("should deflatten a query", () => {
+  describe('deflattenQuery', () => {
+    it('should deflatten a query', () => {
       expect(
         deflattenQuery({
           a: 1,
-          "b.c": 1,
-          "b.d": 1,
-          "e.f.g": 1,
+          'b.c': 1,
+          'b.d': 1,
+          'e.f.g': 1,
         }),
       ).toEqual({
         a: 1,
@@ -47,14 +47,14 @@ if (import.meta.vitest) {
             g: 1,
           },
         },
-      });
-    });
-  });
+      })
+    })
+  })
 
-  it("should handle operators", () => {
+  it('should handle operators', () => {
     expect(
       deflattenQuery({
-        "a.b": 1,
+        'a.b': 1,
         c: {
           $gt: 1,
           $lte: 1,
@@ -68,21 +68,21 @@ if (import.meta.vitest) {
         $gt: 1,
         $lte: 1,
       },
-    });
-  });
+    })
+  })
 
-  it("should handle $or / $and", () => {
+  it('should handle $or / $and', () => {
     expect(
       deflattenQuery({
-        "a.b": 1,
+        'a.b': 1,
         $and: [
           {
-            "c.d": 1,
+            'c.d': 1,
           },
         ],
         $or: [
           {
-            "e.f": 1,
+            'e.f': 1,
           },
         ],
       }),
@@ -104,6 +104,6 @@ if (import.meta.vitest) {
           },
         },
       ],
-    });
-  });
+    })
+  })
 }