@feathersjs/feathers 5.0.0-pre.14 → 5.0.0-pre.15

package/lib/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "5.0.0-pre.14";
+declare const _default: "5.0.0-pre.15";
 export default _default;

package/lib/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = '5.0.0-pre.14';
+exports.default = '5.0.0-pre.15';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@feathersjs/feathers",
   "description": "A framework for real-time applications and REST API with JavaScript and TypeScript",
-  "version": "5.0.0-pre.14",
+  "version": "5.0.0-pre.15",
   "homepage": "http://feathersjs.com",
   "repository": {
     "type": "git",
@@ -57,17 +57,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@feathersjs/commons": "^5.0.0-pre.14",
+    "@feathersjs/commons": "^5.0.0-pre.15",
     "@feathersjs/hooks": "^0.6.5",
     "events": "^3.3.0"
   },
   "devDependencies": {
     "@types/mocha": "^9.0.0",
-    "@types/node": "^16.10.4",
-    "mocha": "^9.1.2",
+    "@types/node": "^16.11.6",
+    "mocha": "^9.1.3",
     "shx": "^0.3.3",
-    "ts-node": "^10.3.0",
+    "ts-node": "^10.4.0",
     "typescript": "^4.4.4"
   },
-  "gitHead": "9bb26276938aead1f3f582be5517a49a8ce00f09"
+  "gitHead": "8008bf4f8529a2a40b6a2f976c1f43ae13675693"
 }

package/src/application.ts

@@ -15,34 +15,34 @@ import {
   HookOptions,
   FeathersService,
   HookMap,
-  LegacyHookMap
+  RegularHookMap
 } from './declarations';
-import { enableLegacyHooks } from './hooks/legacy';
+import { enableRegularHooks } from './hooks/regular';
 
 const debug = createDebug('@feathersjs/feathers');
 
-export class Feathers<ServiceTypes, AppSettings> extends EventEmitter implements FeathersApplication<ServiceTypes, AppSettings> {
-  services: ServiceTypes = ({} as ServiceTypes);
-  settings: AppSettings = ({} as AppSettings);
-  mixins: ServiceMixin<Application<ServiceTypes, AppSettings>>[] = [ hookMixin, eventMixin ];
+export class Feathers<Services, Settings> extends EventEmitter implements FeathersApplication<Services, Settings> {
+  services: Services = ({} as Services);
+  settings: Settings = ({} as Settings);
+  mixins: ServiceMixin<Application<Services, Settings>>[] = [ hookMixin, eventMixin ];
   version: string = version;
   _isSetup = false;
-  appHooks: HookMap<Application<ServiceTypes, AppSettings>, any> = {
+  appHooks: HookMap<Application<Services, Settings>, any> = {
     [HOOKS]: [ (eventHook as any) ]
   };
 
-  private legacyHooks: (this: any, allHooks: any) => any;
+  private regularHooks: (this: any, allHooks: any) => any;
 
   constructor () {
     super();
-    this.legacyHooks = enableLegacyHooks(this);
+    this.regularHooks = enableRegularHooks(this);
   }
 
-  get<L extends keyof AppSettings & string> (name: L): AppSettings[L] {
+  get<L extends keyof Settings & string> (name: L): Settings[L] {
     return this.settings[name];
   }
 
-  set<L extends keyof AppSettings & string> (name: L, value: AppSettings[L]) {
+  set<L extends keyof Settings & string> (name: L, value: Settings[L]) {
     this.settings[name] = value;
     return this;
   }
@@ -53,13 +53,13 @@ export class Feathers<ServiceTypes, AppSettings> extends EventEmitter implements
     return this;
   }
 
-  defaultService (location: string): ServiceInterface<any> {
+  defaultService (location: string): ServiceInterface {
     throw new Error(`Can not find service '${location}'`);
   }
 
-  service<L extends keyof ServiceTypes & string> (
+  service<L extends keyof Services & string> (
     location: L
-  ): FeathersService<this, keyof any extends keyof ServiceTypes ? Service<any> : ServiceTypes[L]> {
+  ): FeathersService<this, keyof any extends keyof Services ? Service : Services[L]> {
     const path = (stripSlashes(location) || '/') as L;
     const current = this.services[path];
 
@@ -71,9 +71,9 @@ export class Feathers<ServiceTypes, AppSettings> extends EventEmitter implements
     return current as any;
   }
 
-  use<L extends keyof ServiceTypes & string> (
+  use<L extends keyof Services & string> (
     path: L,
-    service: keyof any extends keyof ServiceTypes ? ServiceInterface<any> | Application : ServiceTypes[L],
+    service: keyof any extends keyof Services ? ServiceInterface | Application : Services[L],
     options?: ServiceOptions
   ): this {
     if (typeof path !== 'string') {
@@ -118,16 +118,16 @@ export class Feathers<ServiceTypes, AppSettings> extends EventEmitter implements
   }
 
   hooks (hookMap: HookOptions<this, any>) {
-    const legacyMap = hookMap as LegacyHookMap<this, any>;
+    const regularMap = hookMap as RegularHookMap<this, any>;
 
-    if (legacyMap.before || legacyMap.after || legacyMap.error) {
-      return this.legacyHooks(legacyMap);
+    if (regularMap.before || regularMap.after || regularMap.error) {
+      return this.regularHooks(regularMap);
     }
 
     if (Array.isArray(hookMap)) {
       this.appHooks[HOOKS].push(...hookMap as any);
     } else {
-      const methodHookMap = hookMap as HookMap<Application<ServiceTypes, AppSettings>, any>;
+      const methodHookMap = hookMap as HookMap<Application<Services, Settings>, any>;
 
       Object.keys(methodHookMap).forEach(key => {
         const methodHooks = this.appHooks[key] || [];
@@ -146,10 +146,10 @@ export class Feathers<ServiceTypes, AppSettings> extends EventEmitter implements
     for (const path of Object.keys(this.services)) {
       promise = promise.then(() => {
         const service: any = this.service(path as any);
-  
+
         if (typeof service.setup === 'function') {
           debug(`Setting up service for \`${path}\``);
-  
+
           return service.setup(this, path);
         }
       });

package/src/declarations.ts

@@ -18,9 +18,10 @@ export interface ServiceOptions {
   events?: string[];
   methods?: string[];
   serviceEvents?: string[];
+  routeParams?: { [key: string]: any };
 }
 
-export interface ServiceMethods<T, D = Partial<T>> {
+export interface ServiceMethods<T = any, D = Partial<T>> {
   find (params?: Params): Promise<T | T[]>;
 
   get (id: Id, params?: Params): Promise<T>;
@@ -36,7 +37,7 @@ export interface ServiceMethods<T, D = Partial<T>> {
   setup (app: Application, path: string): Promise<void>;
 }
 
-export interface ServiceOverloads<T, D> {
+export interface ServiceOverloads<T = any, D = Partial<T>> {
   create? (data: D[], params?: Params): Promise<T[]>;
 
   update? (id: Id, data: D, params?: Params): Promise<T>;
@@ -52,14 +53,14 @@ export interface ServiceOverloads<T, D> {
   remove? (id: null, params?: Params): Promise<T[]>;
 }
 
-export type Service<T, D = Partial<T>> =
+export type Service<T = any, D = Partial<T>> =
   ServiceMethods<T, D> &
   ServiceOverloads<T, D>;
 
-export type ServiceInterface<T, D = Partial<T>> =
+export type ServiceInterface<T = any, D = Partial<T>> =
   Partial<ServiceMethods<T, D>>;
 
-export interface ServiceAddons<A = Application, S = Service<any, any>> extends EventEmitter {
+export interface ServiceAddons<A = Application, S = Service> extends EventEmitter {
   id?: string;
   hooks (options: HookOptions<A, S>): this;
 }
@@ -103,19 +104,19 @@ export interface ServiceHookOverloads<S> {
   ): Promise<HookContext>;
 }
 
-export type FeathersService<A = FeathersApplication, S = Service<any>> =
+export type FeathersService<A = FeathersApplication, S = Service> =
   S & ServiceAddons<A, S> & OptionalPick<ServiceHookOverloads<S>, keyof S>;
 
-export type CustomMethod<Methods extends string> = {
-  [k in Methods]: <X = any> (data: any, params?: Params) => Promise<X>;
+export type CustomMethods<T extends {[key: string]: [any, any]}> = {
+  [K in keyof T]: (data: T[K][0], params?: Params) => Promise<T[K][1]>;
 }
 
-export type ServiceMixin<A> = (service: FeathersService<A>, path: string, options?: ServiceOptions) => void;
+export type ServiceMixin<A> = (service: FeathersService<A>, path: string, options: ServiceOptions) => void;
 
 export type ServiceGenericType<S> = S extends ServiceInterface<infer T> ? T : any;
 export type ServiceGenericData<S> = S extends ServiceInterface<infer _T, infer D> ? D : any;
 
-export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
+export interface FeathersApplication<Services = any, Settings = any> {
   /**
    * The Feathers application version
    */
@@ -124,7 +125,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
   /**
    * A list of callbacks that run when a new service is registered
    */
-  mixins: ServiceMixin<Application<ServiceTypes, AppSettings>>[];
+  mixins: ServiceMixin<Application<Services, Settings>>[];
 
   /**
    * The index of all services keyed by their path.
@@ -132,13 +133,13 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    * __Important:__ Services should always be retrieved via `app.service('name')`
    * not via `app.services`.
    */
-  services: ServiceTypes;
+  services: Services;
 
   /**
    * The application settings that can be used via
    * `app.get` and `app.set`
    */
-  settings: AppSettings;
+  settings: Settings;
 
   /**
    * A private-ish indicator if `app.setup()` has been called already
@@ -148,14 +149,14 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
   /**
    * Contains all registered application level hooks.
    */
-  appHooks: HookMap<Application<ServiceTypes, AppSettings>, any>;
+  appHooks: HookMap<Application<Services, Settings>, any>;
 
   /**
    * Retrieve an application setting by name
    *
    * @param name The setting name
    */
-  get<L extends keyof AppSettings & string> (name: L): AppSettings[L];
+  get<L extends keyof Settings & string> (name: L): Settings[L];
 
   /**
    * Set an application setting
@@ -163,7 +164,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    * @param name The setting name
    * @param value The setting value
    */
-  set<L extends keyof AppSettings & string> (name: L, value: AppSettings[L]): this;
+  set<L extends keyof Settings & string> (name: L, value: Settings[L]): this;
 
   /**
    * Runs a callback configure function with the current application instance.
@@ -179,7 +180,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    *
    * @param location The path of the service
    */
-  defaultService (location: string): ServiceInterface<any>;
+  defaultService (location: string): ServiceInterface;
 
   /**
    * Register a new service or a sub-app. When passed another
@@ -191,9 +192,9 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    * Feathers application to use a sub-app under the `path` prefix.
    * @param options The options for this service
    */
-  use<L extends keyof ServiceTypes & string> (
+  use<L extends keyof Services & string> (
     path: L,
-    service: keyof any extends keyof ServiceTypes ? ServiceInterface<any> | Application : ServiceTypes[L],
+    service: keyof any extends keyof Services ? ServiceInterface | Application : Services[L],
     options?: ServiceOptions
   ): this;
 
@@ -204,9 +205,9 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
    *
    * @param path The name of the service.
    */
-  service<L extends keyof ServiceTypes & string> (
+  service<L extends keyof Services & string> (
     path: L
-  ): FeathersService<this, keyof any extends keyof ServiceTypes ? Service<any> : ServiceTypes[L]>;
+  ): FeathersService<this, keyof any extends keyof Services ? Service : Services[L]>;
 
   setup (server?: any): Promise<this>;
 
@@ -220,7 +221,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
 
 // This needs to be an interface instead of a type
 // so that the declaration can be extended by other modules
-export interface Application<ServiceTypes = any, AppSettings = any> extends FeathersApplication<ServiceTypes, AppSettings>, EventEmitter {
+export interface Application<Services = any, Settings = any> extends FeathersApplication<Services, Settings>, EventEmitter {
 
 }
 
@@ -234,11 +235,19 @@ export interface Query {
 export interface Params {
   query?: Query;
   provider?: string;
-  route?: { [key: string]: string };
+  route?: { [key: string]: any };
   headers?: { [key: string]: any };
   [key: string]: any; // (JL) not sure if we want this
 }
 
+export interface Http {
+  /**
+   * A writeable, optional property that allows to override the standard HTTP status
+   * code that should be returned.
+   */
+  statusCode?: number;
+}
+
 export interface HookContext<A = Application, S = any> extends BaseHookContext<ServiceGenericType<S>> {
   /**
    * A read only property that contains the Feathers application object. This can be used to
@@ -309,35 +318,41 @@ export interface HookContext<A = Application, S = any> extends BaseHookContext<S
   /**
    * A writeable, optional property that allows to override the standard HTTP status
    * code that should be returned.
+   *
+   * @deprecated Use `http.statusCode` instead.
    */
   statusCode?: number;
+  /**
+   * A writeable, optional property that contains options specific to HTTP transports.
+   */
+  http?: Http;
   /**
    * The event emitted by this method. Can be set to `null` to skip event emitting.
    */
   event: string|null;
 }
 
-// Legacy hook typings
-export type LegacyHookFunction<A = Application, S = Service<any, any>> =
+// Regular hook typings
+export type RegularHookFunction<A = Application, S = Service> =
   (this: S, context: HookContext<A, S>) => (Promise<HookContext<Application, S> | void> | HookContext<Application, S> | void);
 
-export type Hook<A = Application, S = Service<any, any>> = LegacyHookFunction<A, S>;
+export type Hook<A = Application, S = Service> = RegularHookFunction<A, S>;
 
-type LegacyHookMethodMap<A, S> =
-  { [L in keyof S]?: SelfOrArray<LegacyHookFunction<A, S>>; } &
-  { all?: SelfOrArray<LegacyHookFunction<A, S>> };
+type RegularHookMethodMap<A, S> =
+  { [L in keyof S]?: SelfOrArray<RegularHookFunction<A, S>>; } &
+  { all?: SelfOrArray<RegularHookFunction<A, S>> };
 
-type LegacyHookTypeMap<A, S> =
-  SelfOrArray<LegacyHookFunction<A, S>> | LegacyHookMethodMap<A, S>;
+type RegularHookTypeMap<A, S> =
+  SelfOrArray<RegularHookFunction<A, S>> | RegularHookMethodMap<A, S>;
 
-export type LegacyHookMap<A, S> = {
-  before?: LegacyHookTypeMap<A, S>,
-  after?: LegacyHookTypeMap<A, S>,
-  error?: LegacyHookTypeMap<A, S>
+export type RegularHookMap<A, S> = {
+  before?: RegularHookTypeMap<A, S>,
+  after?: RegularHookTypeMap<A, S>,
+  error?: RegularHookTypeMap<A, S>
 }
 
 // New @feathersjs/hook typings
-export type HookFunction<A = Application, S = Service<any, any>> =
+export type HookFunction<A = Application, S = Service> =
   (context: HookContext<A, S>, next: NextFunction) => Promise<void>;
 
 export type HookMap<A, S> = {
@@ -345,4 +360,4 @@ export type HookMap<A, S> = {
 };
 
 export type HookOptions<A, S> =
-  HookMap<A, S> | HookFunction<A, S>[] | LegacyHookMap<A, S>;
+  HookMap<A, S> | HookFunction<A, S>[] | RegularHookMap<A, S>;

package/src/hooks/index.ts

@@ -6,16 +6,20 @@ import {
 } from '../declarations';
 import { defaultServiceArguments, getHookMethods } from '../service';
 import {
-  collectLegacyHooks,
-  enableLegacyHooks,
-  fromAfterHook,
+  collectRegularHooks,
+  enableRegularHooks
+} from './regular';
+
+export {
   fromBeforeHook,
+  fromBeforeHooks,
+  fromAfterHook,
+  fromAfterHooks,
+  fromErrorHook,
   fromErrorHooks
-} from './legacy';
+} from './regular';
 
-export { fromAfterHook, fromBeforeHook, fromErrorHooks };
-
-export function createContext (service: Service<any>, method: string, data: HookContextData = {}) {
+export function createContext (service: Service, method: string, data: HookContextData = {}) {
   const createContext = (service as any)[method].createContext;
 
   if (typeof createContext !== 'function') {
@@ -34,11 +38,11 @@ export class FeathersHookManager<A> extends HookManager {
   collectMiddleware (self: any, args: any[]): Middleware[] {
     const app = this.app as any as Application;
     const appHooks = app.appHooks[HOOKS].concat(app.appHooks[this.method] || []);
-    const legacyAppHooks = collectLegacyHooks(this.app, this.method);
+    const regularAppHooks = collectRegularHooks(this.app, this.method);
     const middleware = super.collectMiddleware(self, args);
-    const legacyHooks = collectLegacyHooks(self, this.method);
+    const regularHooks = collectRegularHooks(self, this.method);
 
-    return [...appHooks, ...legacyAppHooks, ...middleware, ...legacyHooks];
+    return [...appHooks, ...regularAppHooks, ...middleware, ...regularHooks];
   }
 
   initializeContext (self: any, args: any[], context: HookContext) {
@@ -63,7 +67,9 @@ export function hookMixin<A> (
   }
 
   const app = this;
-  const serviceMethodHooks = getHookMethods(service, options).reduce((res, method) => {
+  const hookMethods = getHookMethods(service, options);
+
+  const serviceMethodHooks = hookMethods.reduce((res, method) => {
     const params = (defaultServiceArguments as any)[method] || [ 'data', 'params' ];
 
     res[method] = new FeathersHookManager<A>(app, method)
@@ -74,18 +80,25 @@ export function hookMixin<A> (
         method,
         service,
         event: null,
-        type: null
+        type: null,
+        get statusCode() {
+          return this.http?.statusCode;
+        },
+        set statusCode(value: number) {
+          (this.http ||= {}).statusCode = value;
+        }
       });
 
     return res;
   }, {} as HookMap);
-  const handleLegacyHooks = enableLegacyHooks(service);
+
+  const handleRegularHooks = enableRegularHooks(service, hookMethods);
 
   hooks(service, serviceMethodHooks);
 
   service.hooks = function (this: any, hookOptions: any) {
     if (hookOptions.before || hookOptions.after || hookOptions.error) {
-      return handleLegacyHooks.call(this, hookOptions);
+      return handleRegularHooks.call(this, hookOptions);
     }
 
     if (Array.isArray(hookOptions)) {

package/src/hooks/regular.ts

@@ -0,0 +1,207 @@
+import { HookFunction, RegularHookFunction, RegularHookMap } from '../declarations';
+import { defaultServiceMethods } from '../service';
+
+const runHook = <A, S> (hook: RegularHookFunction<A, S>, context: any, type?: string) => {
+  if (type) context.type = type;
+  return Promise.resolve(hook.call(context.self, context))
+    .then((res: any) => {
+      if (type) context.type = null;
+      if (res && res !== context) {
+        Object.assign(context, res);
+      }
+    });
+};
+
+export function fromBeforeHook<A, S> (hook: RegularHookFunction<A, S>): HookFunction<A, S> {
+  return (context, next) => {
+    return runHook(hook, context, 'before').then(next);
+  };
+}
+
+export function fromAfterHook<A, S> (hook: RegularHookFunction<A, S>): HookFunction<A, S> {
+  return (context, next) => {
+    return next().then(() => runHook(hook, context, 'after'));
+  }
+}
+
+export function fromErrorHook<A, S> (hook: RegularHookFunction<A, S>): HookFunction<A, S> {
+  return (context, next) => {
+    return next().catch((error: any) => {
+      if (context.error !== error || context.result !== undefined) {
+        (context as any).original = { ...context };
+        context.error = error;
+        delete context.result;
+      }
+
+      return runHook(hook, context, 'error').then(() => {
+        if (context.result === undefined && context.error !== undefined) {
+          throw context.error;
+        }
+      });
+    });
+  }
+}
+
+const RunHooks = <A, S> (hooks: RegularHookFunction<A, S>[]) => (context: any) => {
+  return hooks.reduce((promise, hook) => {
+    return promise.then(() => runHook(hook, context))
+  }, Promise.resolve(undefined));
+};
+
+export function fromBeforeHooks<A, S> (hooks: RegularHookFunction<A, S>[]) {
+  return fromBeforeHook(RunHooks(hooks));
+}
+
+export function fromAfterHooks<A, S> (hooks: RegularHookFunction<A, S>[]) {
+  return fromAfterHook(RunHooks(hooks));
+}
+
+export function fromErrorHooks<A, S> (hooks: RegularHookFunction<A, S>[]) {
+  return fromErrorHook(RunHooks(hooks));
+}
+
+export function collectRegularHooks (target: any, method: string) {
+  return target.__hooks.hooks[method] || [];
+}
+
+// Converts different hook registration formats into the
+// same internal format
+export function convertHookData (input: any) {
+  const result: { [ method: string ]: RegularHookFunction[] } = {};
+
+  if (Array.isArray(input)) {
+    result.all = input;
+  } else if (typeof input !== 'object') {
+    result.all = [ input ];
+  } else {
+    for (const key of Object.keys(input)) {
+      const value = input[key];
+      result[key] = Array.isArray(value) ? value : [ value ];
+    }
+  }
+
+  return result;
+}
+
+type RegularType = 'before' | 'after' | 'error';
+
+type RegularMap = { [ type in RegularType ]: ReturnType< typeof convertHookData > };
+
+type RegularAdapter = HookFunction & { hooks: RegularHookFunction[] };
+
+type RegularStore = {
+  before: { [ method: string ]: RegularAdapter },
+  after: { [ method: string ]: RegularAdapter },
+  error: { [ method: string ]: RegularAdapter },
+  hooks: { [ method: string ]: HookFunction[] }
+};
+
+const types: RegularType[] = ['before', 'after', 'error'];
+
+const isType = (value: any): value is RegularType => types.includes(value);
+
+const wrappers = {
+  before: fromBeforeHooks,
+  after: fromAfterHooks,
+  error: fromErrorHooks
+};
+
+const createStore = (methods: string[]) => {
+  const store: RegularStore = {
+    before: {},
+    after: {},
+    error: {},
+    hooks: {}
+  };
+
+  for (const method of methods) {
+    store.hooks[method] = [];
+  }
+
+  return store;
+};
+
+const setStore = (object: any, store: RegularStore) => {
+  Object.defineProperty(object, '__hooks', {
+    configurable: true,
+    value: store,
+    writable: true
+  });
+};
+
+const getStore = (object: any): RegularStore => object.__hooks;
+
+const createMap = (input: RegularHookMap<any, any>, methods: string[]) => {
+  const map = {} as RegularMap;
+
+  Object.keys(input).forEach((type) => {
+    if (!isType(type)) {
+      throw new Error(`'${type}' is not a valid hook type`);
+    }
+
+    const data = convertHookData(input[type]);
+
+    Object.keys(data).forEach((method) => {
+      if (method !== 'all' && !methods.includes(method)) {
+        throw new Error(`'${method}' is not a valid hook method`);
+      }
+    });
+
+    map[type] = data;
+  });
+
+  return map;
+};
+
+const createAdapter = (type: RegularType) => {
+  const hooks: RegularHookFunction[] = [];
+  const hook = wrappers[type](hooks);
+  const adapter = Object.assign(hook, { hooks });
+
+  return adapter;
+};
+
+const updateStore = (store: RegularStore, map: RegularMap) => {
+  Object.keys(store.hooks).forEach((method) => {
+    let adapted = false;
+
+    Object.keys(map).forEach((key) => {
+      const type = key as RegularType;
+      const allHooks = map[type].all || [];
+      const methodHooks = map[type][method] || [];
+
+      if (allHooks.length || methodHooks.length) {
+        const adapter = store[type][method] ||= (adapted = true, createAdapter(type));
+
+        adapter.hooks.push(...allHooks, ...methodHooks);
+      }
+    });
+
+    if (adapted) {
+      store.hooks[method] = [
+        store.error[method],
+        store.before[method],
+        store.after[method]
+      ].filter(hook => hook);
+    }
+  });
+};
+
+// Add `.hooks` functionality to an object
+export function enableRegularHooks (
+  object: any,
+  methods: string[] = defaultServiceMethods
+) {
+  const store = createStore(methods);
+
+  setStore(object, store);
+
+  return function regularHooks (this: any, input: RegularHookMap<any, any>) {
+    const store = getStore(this);
+    const map = createMap(input, methods);
+
+    updateStore(store, map);
+
+    return this;
+  }
+}