@feathersjs/feathers 5.0.0-pre.6 → 5.0.0

package/src/hooks/index.ts

@@ -1,109 +0,0 @@
-import {
-  getManager, HookContextData, HookManager, HookMap, HOOKS, hooks, Middleware
-} from '../dependencies';
-import {
-  Service, ServiceOptions, HookContext, FeathersService, Application
-} from '../declarations';
-import { defaultServiceArguments, getHookMethods } from '../service';
-import {
-  collectLegacyHooks,
-  enableLegacyHooks,
-  fromAfterHook,
-  fromBeforeHook,
-  fromErrorHooks
-} from './legacy';
-
-export { fromAfterHook, fromBeforeHook, fromErrorHooks };
-
-export function createContext (service: Service<any>, method: string, data: HookContextData = {}) {
-  const createContext = (service as any)[method].createContext;
-
-  if (typeof createContext !== 'function') {
-    throw new Error(`Can not create context for method ${method}`);
-  }
-
-  return createContext(data) as HookContext;
-}
-
-export class FeathersHookManager<A> extends HookManager {
-  constructor (public app: A, public method: string) {
-    super();
-    this._middleware = [];
-  }
-
-  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 middleware = super.collectMiddleware(self, args);
-    const legacyHooks = collectLegacyHooks(self, this.method);
-
-    return [...appHooks, ...legacyAppHooks, ...middleware, ...legacyHooks];
-  }
-
-  initializeContext (self: any, args: any[], context: HookContext) {
-    const ctx = super.initializeContext(self, args, context);
-
-    ctx.params = ctx.params || {};
-
-    return ctx;
-  }
-
-  middleware (mw: Middleware[]) {
-    this._middleware.push(...mw);
-    return this;
-  }
-}
-
-export function hookMixin<A> (
-  this: A, service: FeathersService<A>, path: string, options: ServiceOptions
-) {
-  if (typeof service.hooks === 'function') {
-    return service;
-  }
-
-  const app = this;
-  const serviceMethodHooks = getHookMethods(service, options).reduce((res, method) => {
-    const params = (defaultServiceArguments as any)[method] || [ 'data', 'params' ];
-
-    res[method] = new FeathersHookManager<A>(app, method)
-      .params(...params)
-      .props({
-        app,
-        path,
-        method,
-        service,
-        event: null,
-        type: null
-      });
-
-    return res;
-  }, {} as HookMap);
-  const handleLegacyHooks = enableLegacyHooks(service);
-
-  hooks(service, serviceMethodHooks);
-
-  service.hooks = function (this: any, hookOptions: any) {
-    if (hookOptions.before || hookOptions.after || hookOptions.error) {
-      return handleLegacyHooks.call(this, hookOptions);
-    }
-
-    if (Array.isArray(hookOptions)) {
-      return hooks(this, hookOptions);
-    }
-
-    Object.keys(hookOptions).forEach(method => {
-      const manager = getManager(this[method]);
-
-      if (!(manager instanceof FeathersHookManager)) {
-        throw new Error(`Method ${method} is not a Feathers hooks enabled service method`);
-      }
-
-      manager.middleware(hookOptions[method]);
-    });
-
-    return this;
-  }
-
-  return service;
-}

package/src/hooks/legacy.ts

@@ -1,138 +0,0 @@
-import { _ } from '../dependencies';
-import { LegacyHookFunction } from '../declarations';
-
-const { each } = _;
-
-export function fromBeforeHook (hook: LegacyHookFunction) {
-  return (context: any, next: any) => {
-    context.type = 'before';
-
-    return Promise.resolve(hook.call(context.self, 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(() => {
-      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))
-      }
-
-      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;
-  }
-}