Revert pull request #37

packages/hooks/src/base.ts

@@ -1,9 +1,13 @@
 import { Middleware } from './compose';
+import { copyToSelf } from './utils';
 
 export const HOOKS: string = Symbol('@feathersjs/hooks') as any;
 
 export type HookContextData = { [key: string]: any };
 
+/**
+ * The base hook context.
+ */
 export class HookContext<T = any, C = any> {
   result?: T;
   method?: string;
@@ -18,11 +22,14 @@ export class HookContext<T = any, C = any> {
 
 export type HookContextConstructor = new (data?: { [key: string]: any }) => HookContext;
 
-export type HookDefaultsInitializer = (context: HookContext) => HookContextData;
+export type HookDefaultsInitializer = (self?: any, args?: any[], context?: HookContext) => HookContextData;
 
 export class HookManager {
   _parent?: this|null = null;
+  _params: string[] = [];
   _middleware: Middleware[] = [];
+  _props: HookContextData = {};
+  _defaults: HookDefaultsInitializer;
 
   parent (parent: this) {
     this._parent = parent;
@@ -36,32 +43,103 @@ export class HookManager {
     return this;
   }
 
-  getContextClass (): HookContextConstructor {
-    return HookContext;
-  }
-
   getMiddleware (): Middleware[] {
     const previous = this._parent ? this._parent.getMiddleware() : [];
 
     return previous.concat(this._middleware);
   }
 
-   collectMiddleware (self: any, _args: any[]): Middleware[] {
+  collectMiddleware (self: any, _args: any[]): Middleware[] {
     const otherMiddleware = getMiddleware(self);
 
     return otherMiddleware.concat(this.getMiddleware());
   }
 
+  props (props: HookContextData) {
+    Object.assign(this._props, props);
+
+    return this;
+  }
+
+  getProps (): HookContextData {
+    const previous = this._parent ? this._parent.getProps() : {};
+
+    return Object.assign({}, previous, this._props);
+  }
+
+  params (...params: string[]) {
+    this._params = params;
+
+    return this;
+  }
+
+  getParams (): string[] {
+    const previous = this._parent ? this._parent.getParams() : [];
+
+    return previous.concat(this._params);
+  }
+
+  defaults (defaults: HookDefaultsInitializer) {
+    this._defaults = defaults;
+
+    return this;
+  }
+
+  getDefaults (self: any, args: any[], context: HookContext): HookContextData {
+    const previous = this._parent ? this._parent.getDefaults(self, args, context) : {};
+    const defaults = typeof this._defaults === 'function' ? this._defaults(self, args, context) : {};
+
+    return Object.assign({}, previous, defaults);
+  }
+
+  getContextClass (Base: HookContextConstructor = HookContext): HookContextConstructor {
+    const ContextClass = class ContextClass extends Base {
+      constructor (data: any) {
+        super(data);
+
+        copyToSelf(this);
+      }
+    };
+    const params = this.getParams();
+    const props = this.getProps();
+
+    params.forEach((name, index) => {
+      if (props[name]) {
+        throw new Error(`Hooks can not have a property and param named '${name}'. Use .defaults instead.`);
+      }
+
+      Object.defineProperty(ContextClass.prototype, name, {
+        enumerable: true,
+        get () {
+          return this?.arguments[index];
+        },
+        set (value: any) {
+          this.arguments[index] = value;
+        }
+      });
+    });
+
+    Object.assign(ContextClass.prototype, props);
+
+    return ContextClass;
+  }
 
   initializeContext (self: any, args: any[], context: HookContext): HookContext {
     const ctx = this._parent ? this._parent.initializeContext(self, args, context) : context;
+    const defaults = this.getDefaults(self, args, ctx);
 
     if (self) {
       ctx.self = self;
     }
 
     ctx.arguments = args;
 
+    for (const name of Object.keys(defaults)) {
+      if (ctx[name] === undefined) {
+        ctx[name] = defaults[name];
+      }
+    }
+
     return ctx;
   }
 }

packages/hooks/src/decorator.ts

@@ -0,0 +1,26 @@
+import { functionHooks } from './hooks';
+import { setManager, HookOptions, convertOptions } from './base';
+
+export const hookDecorator = (managerOrMiddleware?: HookOptions) => {
+  const wrapper: any = (_target: any, method: string, descriptor: TypedPropertyDescriptor<any>): TypedPropertyDescriptor<any> => {
+    const manager = convertOptions(managerOrMiddleware);
+
+    if (!descriptor) {
+      setManager(_target.prototype, manager);
+
+      return _target;
+    }
+
+    const fn = descriptor.value;
+
+    if (typeof fn !== 'function') {
+      throw new Error(`Can not apply hooks. '${method}' is not a function`);
+    }
+
+    descriptor.value = functionHooks(fn, manager.props({ method }));
+
+    return descriptor;
+  };
+
+  return wrapper;
+};

packages/hooks/src/hooks.ts

@@ -2,15 +2,14 @@ import { compose, Middleware } from './compose';
 import {
   HookContext, setManager, HookContextData, HookOptions, convertOptions, setMiddleware
 } from './base';
-import { properties } from './context';
 
 export function getOriginal (fn: any): any {
   return typeof fn.original === 'function' ? getOriginal(fn.original) : fn;
 }
 
 function copyProperties <F> (target: F, original: any) {
   const originalProps = (Object.keys(original) as any)
-    .concat(Object.getOwnPropertySymbols(original));
+      .concat(Object.getOwnPropertySymbols(original));
 
   for (const prop of originalProps) {
     const propDescriptor = Object.getOwnPropertyDescriptor(original, prop);
@@ -92,9 +91,7 @@ export function objectHooks (_obj: any, hooks: HookMap|Middleware[]) {
 
     const manager = convertOptions(hooks[method]);
 
-    manager._middleware.unshift(properties({ method }));
-
-    result[method] = functionHooks(fn, manager);
+    result[method] = functionHooks(fn, manager.props({ method }));
 
     return result;
   }, obj);
@@ -116,8 +113,7 @@ export const hookDecorator = (managerOrMiddleware?: HookOptions) => {
       throw new Error(`Can not apply hooks. '${method}' is not a function`);
     }
 
-    manager._middleware.unshift(properties({ method }));
-    descriptor.value = functionHooks(fn, manager);
+    descriptor.value = functionHooks(fn, manager.props({ method }));
 
     return descriptor;
   };

packages/hooks/src/index.ts

@@ -4,7 +4,6 @@ import {
 } from './base';
 import { functionHooks, hookDecorator, objectHooks, HookMap } from './hooks';
 
-export * as setContext from './context';
 export * from './hooks';
 export * from './compose';
 export * from './base';

packages/hooks/src/object.ts

@@ -0,0 +1,29 @@
+import { Middleware } from './compose';
+import { functionHooks } from './hooks';
+import { setMiddleware, convertOptions, HookOptions } from './base';
+
+export type HookMap<O = any> = {
+  [L in keyof O]?: HookOptions;
+}
+
+export function objectHooks (_obj: any, hooks: HookMap|Middleware[]) {
+  const obj = typeof _obj === 'function' ? _obj.prototype : _obj;
+
+  if (Array.isArray(hooks)) {
+    return setMiddleware(obj, hooks);
+  }
+
+  return Object.keys(hooks).reduce((result, method) => {
+    const fn = obj[method];
+
+    if (typeof fn !== 'function') {
+      throw new Error(`Can not apply hooks. '${method}' is not a function`);
+    }
+
+    const manager = convertOptions(hooks[method]);
+
+    result[method] = functionHooks(fn, manager.props({ method }));
+
+    return result;
+  }, obj);
+};

packages/hooks/src/utils.ts

@@ -0,0 +1,25 @@
+const proto = Object.prototype as any;
+// These are non-standard but offer a more reliable prototype based
+// lookup for properties
+const hasProtoDefinitions = typeof proto.__lookupGetter__ === 'function' &&
+  typeof proto.__defineGetter__ === 'function' &&
+  typeof proto.__defineSetter__ === 'function';
+
+export function copyToSelf (target: any) {
+  // tslint:disable-next-line
+  for (const key in target) {
+    if (!target.hasOwnProperty(key)) {
+      const getter = hasProtoDefinitions ? target.constructor.prototype.__lookupGetter__(key)
+        : Object.getOwnPropertyDescriptor(target, key);
+
+      if (getter && hasProtoDefinitions) {
+        target.__defineGetter__(key, getter);
+        target.__defineSetter__(key, target.constructor.prototype.__lookupSetter__(key));
+      } else if (getter) {
+        Object.defineProperty(target, key, getter);
+      } else {
+        target[key] = target[key];
+      }
+    }
+  }
+}

packages/hooks/test/benchmark.test.ts

@@ -1,11 +1,5 @@
 import { strict as assert } from 'assert';
-import {
-  hooks,
-  HookContext,
-  NextFunction,
-  middleware,
-  setContext
-} from '../src/';
+import { hooks, HookContext, NextFunction, middleware } from '../src/';
 
 const CYCLES = 100000;
 const getRuntime = async (callback: () => Promise<any>) => {
@@ -50,12 +44,10 @@ describe('hook benchmark', () => {
 
   it('single hook, withParams and props', async () => {
     const hookHello = hooks(hello, middleware([
-      setContext.params('name'),
-      setContext.properties({ dave: true }),
       async (_ctx: HookContext, next: NextFunction) => {
         await next();
       }
-    ]));
+    ]).params('name').props({ dave: true }));
 
     const runtime = await getRuntime(() => hookHello('Dave'));