@feathersjs/feathers 5.0.0-pre.11 → 5.0.0-pre.17

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;
+  }
+}

package/src/service.ts

@@ -24,6 +24,7 @@ export const defaultEventMap = {
 export const protectedMethods = Object.keys(Object.prototype)
   .concat(Object.keys(EventEmitter.prototype))
   .concat([
+    'all',
     'before',
     'after',
     'error',

package/src/version.ts

@@ -1 +1 @@
-export default 'development';
+export default '5.0.0-pre.17';

package/lib/hooks/legacy.d.ts

@@ -1,7 +0,0 @@
-import { LegacyHookFunction } from '../declarations';
-export declare function fromBeforeHook(hook: LegacyHookFunction): (context: any, next: any) => Promise<any>;
-export declare function fromAfterHook(hook: LegacyHookFunction): (context: any, next: any) => any;
-export declare function fromErrorHooks(hooks: LegacyHookFunction[]): (context: any, next: any) => any;
-export declare function collectLegacyHooks(target: any, method: string): any[];
-export declare function convertHookData(obj: any): any;
-export declare function enableLegacyHooks(obj: any, methods?: string[], types?: string[]): (this: any, allHooks: any) => any;

package/lib/hooks/legacy.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.enableLegacyHooks = exports.convertHookData = exports.collectLegacyHooks = exports.fromErrorHooks = exports.fromAfterHook = exports.fromBeforeHook = void 0;
-const dependencies_1 = require("../dependencies");
-const { each } = dependencies_1._;
-const mergeContext = (context) => (res) => {
-    if (res && res !== context) {
-        Object.assign(context, res);
-    }
-    return res;
-};
-function fromBeforeHook(hook) {
-    return (context, next) => {
-        context.type = 'before';
-        return Promise.resolve(hook.call(context.self, context))
-            .then(mergeContext(context))
-            .then(() => {
-            context.type = null;
-            return next();
-        });
-    };
-}
-exports.fromBeforeHook = fromBeforeHook;
-function fromAfterHook(hook) {
-    return (context, next) => {
-        return next()
-            .then(() => {
-            context.type = 'after';
-            return hook.call(context.self, context);
-        })
-            .then(mergeContext(context))
-            .then(() => {
-            context.type = null;
-        });
-    };
-}
-exports.fromAfterHook = fromAfterHook;
-function fromErrorHooks(hooks) {
-    return (context, next) => {
-        return next().catch((error) => {
-            let promise = Promise.resolve();
-            context.original = { ...context };
-            context.error = error;
-            context.type = 'error';
-            delete context.result;
-            for (const hook of hooks) {
-                promise = promise.then(() => hook.call(context.self, context))
-                    .then(mergeContext(context));
-            }
-            return promise.then(() => {
-                context.type = null;
-                if (context.result === undefined) {
-                    throw context.error;
-                }
-            });
-        });
-    };
-}
-exports.fromErrorHooks = fromErrorHooks;
-function collectLegacyHooks(target, method) {
-    const { before: { [method]: before = [] }, after: { [method]: after = [] }, error: { [method]: error = [] } } = target.__hooks;
-    const beforeHooks = before;
-    const afterHooks = [...after].reverse();
-    const errorHook = fromErrorHooks(error);
-    return [errorHook, ...beforeHooks, ...afterHooks];
-}
-exports.collectLegacyHooks = collectLegacyHooks;
-// Converts different hook registration formats into the
-// same internal format
-function convertHookData(obj) {
-    let hook = {};
-    if (Array.isArray(obj)) {
-        hook = { all: obj };
-    }
-    else if (typeof obj !== 'object') {
-        hook = { all: [obj] };
-    }
-    else {
-        each(obj, function (value, key) {
-            hook[key] = !Array.isArray(value) ? [value] : value;
-        });
-    }
-    return hook;
-}
-exports.convertHookData = convertHookData;
-// Add `.hooks` functionality to an object
-function enableLegacyHooks(obj, methods = ['find', 'get', 'create', 'update', 'patch', 'remove'], types = ['before', 'after', 'error']) {
-    const hookData = {};
-    types.forEach(type => {
-        // Initialize properties where hook functions are stored
-        hookData[type] = {};
-    });
-    // Add non-enumerable `__hooks` property to the object
-    Object.defineProperty(obj, '__hooks', {
-        configurable: true,
-        value: hookData,
-        writable: true
-    });
-    return function legacyHooks(allHooks) {
-        each(allHooks, (current, type) => {
-            if (!this.__hooks[type]) {
-                throw new Error(`'${type}' is not a valid hook type`);
-            }
-            const hooks = convertHookData(current);
-            each(hooks, (_value, method) => {
-                if (method !== 'all' && methods.indexOf(method) === -1) {
-                    throw new Error(`'${method}' is not a valid hook method`);
-                }
-            });
-            methods.forEach(method => {
-                let currentHooks = [...(hooks.all || []), ...(hooks[method] || [])];
-                this.__hooks[type][method] = this.__hooks[type][method] || [];
-                if (type === 'before') {
-                    currentHooks = currentHooks.map(fromBeforeHook);
-                }
-                if (type === 'after') {
-                    currentHooks = currentHooks.map(fromAfterHook);
-                }
-                this.__hooks[type][method].push(...currentHooks);
-            });
-        });
-        return this;
-    };
-}
-exports.enableLegacyHooks = enableLegacyHooks;
-//# sourceMappingURL=legacy.js.map

package/lib/hooks/legacy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacy.js","sourceRoot":"","sources":["../../src/hooks/legacy.ts"],"names":[],"mappings":"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"}

package/src/hooks/legacy.ts

@@ -1,150 +0,0 @@
-import { _ } from '../dependencies';
-import { LegacyHookFunction } from '../declarations';
-
-const { each } = _;
-const mergeContext = (context: any) => (res: any) => {
-  if (res && res !== context) {
-    Object.assign(context, res);
-  }
-  return res;
-}
-
-export function fromBeforeHook (hook: LegacyHookFunction) {
-  return (context: any, next: any) => {
-    context.type = 'before';
-
-    return Promise.resolve(hook.call(context.self, context))
-      .then(mergeContext(context))
-      .then(() => {
-        context.type = null;
-        return next();
-      });
-  };
-}
-
-export function fromAfterHook (hook: LegacyHookFunction) {
-  return (context: any, next: any) => {
-    return next()
-      .then(() => {
-        context.type = 'after';
-        return hook.call(context.self, context)
-      })
-      .then(mergeContext(context))
-      .then(() => {
-        context.type = null;
-      });
-  }
-}
-
-export function fromErrorHooks (hooks: LegacyHookFunction[]) {
-  return (context: any, next: any) => {
-    return next().catch((error: any) => {
-      let promise: Promise<any> = Promise.resolve();
-
-      context.original = { ...context };
-      context.error = error;
-      context.type = 'error';
-
-      delete context.result;
-
-      for (const hook of hooks) {
-        promise = promise.then(() => hook.call(context.self, context))
-          .then(mergeContext(context))
-      }
-
-      return promise.then(() => {
-        context.type = null;
-
-        if (context.result === undefined) {
-          throw context.error;
-        }
-      });
-    });
-  }
-}
-
-export function collectLegacyHooks (target: any, method: string) {
-  const {
-    before: { [method]: before = [] },
-    after: { [method]: after = [] },
-    error: { [method]: error = [] }
-  } = target.__hooks;
-  const beforeHooks = before;
-  const afterHooks = [...after].reverse();
-  const errorHook = fromErrorHooks(error);
-
-  return [errorHook, ...beforeHooks, ...afterHooks];
-}
-
-// Converts different hook registration formats into the
-// same internal format
-export function convertHookData (obj: any) {
-  let hook: any = {};
-
-  if (Array.isArray(obj)) {
-    hook = { all: obj };
-  } else if (typeof obj !== 'object') {
-    hook = { all: [ obj ] };
-  } else {
-    each(obj, function (value, key) {
-      hook[key] = !Array.isArray(value) ? [ value ] : value;
-    });
-  }
-
-  return hook;
-}
-
-// Add `.hooks` functionality to an object
-export function enableLegacyHooks (
-  obj: any,
-  methods: string[] = ['find', 'get', 'create', 'update', 'patch', 'remove'],
-  types: string[] = ['before', 'after', 'error']
-) {
-  const hookData: any = {};
-
-  types.forEach(type => {
-    // Initialize properties where hook functions are stored
-    hookData[type] = {};
-  });
-
-  // Add non-enumerable `__hooks` property to the object
-  Object.defineProperty(obj, '__hooks', {
-    configurable: true,
-    value: hookData,
-    writable: true
-  });
-
-  return function legacyHooks (this: any, allHooks: any) {
-    each(allHooks, (current: any, type) => {
-      if (!this.__hooks[type]) {
-        throw new Error(`'${type}' is not a valid hook type`);
-      }
-
-      const hooks = convertHookData(current);
-
-      each(hooks, (_value, method) => {
-        if (method !== 'all' && methods.indexOf(method) === -1) {
-          throw new Error(`'${method}' is not a valid hook method`);
-        }
-      });
-
-      methods.forEach(method => {
-        let currentHooks = [...(hooks.all || []), ...(hooks[method] || [])];
-
-        this.__hooks[type][method] = this.__hooks[type][method] || [];
-
-        if (type === 'before') {
-          currentHooks = currentHooks.map(fromBeforeHook);
-        }
-
-        if (type === 'after') {
-          currentHooks = currentHooks.map(fromAfterHook);
-        }
-
-        this.__hooks[type][method].push(...currentHooks);
-      });
-    });
-
-    return this;
-  }
-}