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

package/src/hooks/index.ts

@@ -1,177 +1,122 @@
-import * as hookCommons from './commons';
 import {
-  hooks as hooksDecorator,
-  HookManager,
-  HookContext,
-  HookMap,
-  Middleware,
-  middleware
-} from '@feathersjs/hooks';
-import { assignArguments, validate } from './base';
-import { Application, Service } from '../declarations';
-const baseHooks = [ assignArguments, validate ];
-const {
-  getHooks,
-  enableHooks,
-  ACTIVATE_HOOKS,
-  finallyWrapper,
-  errorWrapper,
-  wrap
-} = hookCommons;
-
-function getMiddlewareOptions (app: Application, service: Service<any>, method: string) {
-  const params: string[] = service.methods[method];
-  const defaults = params.find(v => v === 'params') ? { params: {} } : null;
-
-  return {
-    params,
-    defaults,
-    props: {
-      app,
-      service,
-      type: 'before',
-      get path () {
-        if (!service || !app || !app.services) {
-          return null;
-        }
-
-        return Object.keys(app.services)
-          .find(path => app.services[path] === service);
-      }
-    }
-  };
-}
-
-function getCollector (app: Application, service: Service<any>, method: string) {
-  return function (this: HookManager): Middleware[] {
-    const previous = this._parent && this._parent.getMiddleware();
-    let result;
-
-    if (previous && this._middleware) {
-      result = previous.concat(this._middleware);
-    } else {
-      result = previous || this._middleware || [];
-    }
+  getManager, HookContextData, HookManager, HookMap, HOOKS, hooks, Middleware
+} from '../dependencies';
+import {
+  Service, ServiceOptions, HookContext, FeathersService, Application
+} from '../declarations';
+import { defaultServiceArguments, getHookMethods } from '../service';
+import {
+  collectRegularHooks,
+  enableRegularHooks
+} from './regular';
+
+export {
+  fromBeforeHook,
+  fromBeforeHooks,
+  fromAfterHook,
+  fromAfterHooks,
+  fromErrorHook,
+  fromErrorHooks
+} from './regular';
+
+export function createContext (service: Service, 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}`);
+  }
 
-    const hooks = {
-      async: getHooks(app, service, 'async', method),
-      before: getHooks(app, service, 'before', method),
-      after: getHooks(app, service, 'after', method, true),
-      error: getHooks(app, service, 'error', method, true),
-      finally: getHooks(app, service, 'finally', method, true)
-    };
-
-    return [
-      ...finallyWrapper(hooks.finally),
-      ...errorWrapper(hooks.error),
-      ...baseHooks,
-      ...result,
-      ...wrap(hooks)
-    ];
-  };
+  return createContext(data) as HookContext;
 }
 
-function withHooks (app: Application, service: Service<any>, methods: string[]) {
-  const hookMap = methods.reduce((accu, method) => {
-    if (typeof service[method] !== 'function') {
-      return accu;
-    }
-
-    const hookManager = middleware([], getMiddlewareOptions(app, service, method));
-
-    hookManager.getMiddleware = getCollector(app, service, method);
-
-    accu[method] = hookManager;
+export class FeathersHookManager<A> extends HookManager {
+  constructor (public app: A, public method: string) {
+    super();
+    this._middleware = [];
+  }
 
-    return accu;
-  }, {} as HookMap);
+  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 regularAppHooks = collectRegularHooks(this.app, this.method);
+    const middleware = super.collectMiddleware(self, args);
+    const regularHooks = collectRegularHooks(self, this.method);
 
-  hooksDecorator(service, hookMap);
-}
+    return [...appHooks, ...regularAppHooks, ...middleware, ...regularHooks];
+  }
 
-function mixinMethod (this: any) {
-  const service = this;
-  const args = Array.from(arguments);
+  initializeContext (self: any, args: any[], context: HookContext) {
+    const ctx = super.initializeContext(self, args, context);
 
-  const returnHook = args[args.length - 1] === true || args[args.length - 1] instanceof HookContext
-    ? args.pop() : false;
+    ctx.params = ctx.params || {};
 
-  const hookContext = returnHook instanceof HookContext ? returnHook : this._super.createContext();
+    return ctx;
+  }
 
-  return this._super.call(service, ...args, hookContext)
-    .then(() => returnHook ? hookContext : hookContext.result)
-    // Handle errors
-    .catch(() => {
-      if (typeof hookContext.error !== 'undefined' && typeof hookContext.result === 'undefined') {
-        return Promise.reject(returnHook ? hookContext : hookContext.error);
-      } else {
-        return returnHook ? hookContext : hookContext.result;
-      }
-    });
+  middleware (mw: Middleware[]) {
+    this._middleware.push(...mw);
+    return this;
+  }
 }
 
-// A service mixin that adds `service.hooks()` method and functionality
-const hookMixin = exports.hookMixin = function hookMixin (service: any) {
+export function hookMixin<A> (
+  this: A, service: FeathersService<A>, path: string, options: ServiceOptions
+) {
   if (typeof service.hooks === 'function') {
-    return;
+    return service;
   }
 
-  service.methods = Object.getOwnPropertyNames(service)
-    .filter(key => typeof service[key] === 'function' && service[key][ACTIVATE_HOOKS])
-    .reduce((result, methodName) => {
-      result[methodName] = service[methodName][ACTIVATE_HOOKS];
-      return result;
-    }, service.methods || {});
-
-  Object.assign(service.methods, {
-    find: ['params'],
-    get: ['id', 'params'],
-    create: ['data', 'params'],
-    update: ['id', 'data', 'params'],
-    patch: ['id', 'data', 'params'],
-    remove: ['id', 'params']
-  });
-
   const app = this;
-  const methodNames = Object.keys(service.methods);
+  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)
+      .params(...params)
+      .props({
+        app,
+        path,
+        method,
+        service,
+        event: null,
+        type: null,
+        get statusCode() {
+          return this.http?.statusCode;
+        },
+        set statusCode(value: number) {
+          (this.http ||= {}).statusCode = value;
+        }
+      });
 
-  withHooks(app, service, methodNames);
+    return res;
+  }, {} as HookMap);
 
-  // Usefull only for the `returnHook` backwards compatibility with `true`
-  const mixin = methodNames.reduce((mixin, method) => {
-    if (typeof service[method] !== 'function') {
-      return mixin;
-    }
+  const handleRegularHooks = enableRegularHooks(service, hookMethods);
 
-    mixin[method] = mixinMethod;
+  hooks(service, serviceMethodHooks);
 
-    return mixin;
-  }, {} as any);
+  service.hooks = function (this: any, hookOptions: any) {
+    if (hookOptions.before || hookOptions.after || hookOptions.error) {
+      return handleRegularHooks.call(this, hookOptions);
+    }
 
-  // Add .hooks method and properties to the service
-  enableHooks(service, methodNames, app.hookTypes);
+    if (Array.isArray(hookOptions)) {
+      return hooks(this, hookOptions);
+    }
 
-  service.mixin(mixin);
-};
+    Object.keys(hookOptions).forEach(method => {
+      const manager = getManager(this[method]);
 
-export default function () {
-  return function (app: any) {
-    // We store a reference of all supported hook types on the app
-    // in case someone needs it
-    Object.assign(app, {
-      hookTypes: ['async', 'before', 'after', 'error', 'finally']
-    });
+      if (!(manager instanceof FeathersHookManager)) {
+        throw new Error(`Method ${method} is not a Feathers hooks enabled service method`);
+      }
 
-    // Add functionality for hooks to be registered as app.hooks
-    enableHooks(app, app.methods, app.hookTypes);
+      manager.middleware(hookOptions[method]);
+    });
 
-    app.mixins.push(hookMixin);
-  };
-}
+    return this;
+  }
 
-export function activateHooks (args: any[]) {
-  return (fn: any) => {
-    Object.defineProperty(fn, ACTIVATE_HOOKS, { value: args });
-    return fn;
-  };
+  return service;
 }

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/index.ts

@@ -1,25 +1,18 @@
-// @ts-ignore
-import Proto from 'uberproto';
-import Application from './application';
+import { setDebug } from './dependencies';
 import version from './version';
-import { Application as ApplicationType } from './declarations'
+import { Feathers } from './application';
+import { Application } from './declarations';
 
-const baseObject = Object.create(null);
-
-export default function feathers<ServiceTypes = {}> (): ApplicationType<ServiceTypes> {
-  const app = Object.create(baseObject);
-
-  // Mix in the base application
-  Proto.mixin(Application, app);
-
-  app.init();
-
-  return app;
+export function feathers<T = any, S = any> () {
+  return new Feathers<T, S>() as Application<T, S>;
 }
 
-export { version };
-export * from './declarations';
+feathers.setDebug = setDebug;
+
+export { version, Feathers };
 export * from './hooks/index';
+export * from './declarations';
+export * from './service';
 
 if (typeof module !== 'undefined') {
   module.exports = Object.assign(feathers, module.exports);

package/src/service.ts

@@ -0,0 +1,91 @@
+import { createSymbol, EventEmitter } from './dependencies';
+import { ServiceOptions } from './declarations';
+
+export const SERVICE = createSymbol('@feathersjs/service');
+
+export const defaultServiceArguments = {
+  find: [ 'params' ],
+  get: [ 'id', 'params' ],
+  create: [ 'data', 'params' ],
+  update: [ 'id', 'data', 'params' ],
+  patch: [ 'id', 'data', 'params' ],
+  remove: [ 'id', 'params' ]
+}
+
+export const defaultServiceMethods = Object.keys(defaultServiceArguments);
+
+export const defaultEventMap = {
+  create: 'created',
+  update: 'updated',
+  patch: 'patched',
+  remove: 'removed'
+}
+
+export const protectedMethods = Object.keys(Object.prototype)
+  .concat(Object.keys(EventEmitter.prototype))
+  .concat([
+    'all',
+    'before',
+    'after',
+    'error',
+    'hooks',
+    'setup',
+    'publish'
+  ]);
+
+export function getHookMethods (service: any, options: ServiceOptions) {
+  const { methods } = options;
+
+  return defaultServiceMethods.filter(m =>
+    typeof service[m] === 'function' && !methods.includes(m)
+  ).concat(methods);
+}
+
+export function getServiceOptions (
+  service: any, options: ServiceOptions = {}
+): ServiceOptions {
+  const existingOptions = service[SERVICE];
+
+  if (existingOptions) {
+    return existingOptions;
+  }
+
+  const {
+    methods = defaultServiceMethods.filter(method =>
+      typeof service[method] === 'function'
+    ),
+    events = service.events || []
+  } = options;
+  const {
+    serviceEvents = Object.values(defaultEventMap).concat(events)
+  } = options;
+
+  return {
+    ...options,
+    events,
+    methods,
+    serviceEvents
+  };
+}
+
+export function wrapService (
+  location: string, service: any, options: ServiceOptions
+) {
+  // Do nothing if this is already an initialized
+  if (service[SERVICE]) {
+    return service;
+  }
+
+  const protoService = Object.create(service);
+  const serviceOptions = getServiceOptions(service, options);
+
+  if (Object.keys(serviceOptions.methods).length === 0 && typeof service.setup !== 'function') {
+    throw new Error(`Invalid service object passed for path \`${location}\``);
+  }
+
+  Object.defineProperty(protoService, SERVICE, {
+    value: serviceOptions
+  });
+
+  return protoService;
+}

package/src/version.ts

@@ -1 +1 @@
-export default '5.0.0-pre.1';
+export default '5.0.0-pre.15';

package/lib/hooks/base.d.ts

@@ -1,3 +0,0 @@
-import { HookContext } from '../declarations';
-export declare const assignArguments: (context: HookContext, next: any) => any;
-export declare const validate: (context: HookContext, next: any) => any;

package/lib/hooks/base.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validate = exports.assignArguments = void 0;
-const commons_1 = require("@feathersjs/commons");
-const assignArguments = (context, next) => {
-    const { service, method } = context;
-    const parameters = service.methods[method];
-    context.arguments.forEach((value, index) => {
-        context[parameters[index]] = value;
-    });
-    if (!context.params) {
-        context.params = {};
-    }
-    return next();
-};
-exports.assignArguments = assignArguments;
-const validate = (context, next) => {
-    const { service, method, path } = context;
-    const parameters = service.methods[method];
-    if (parameters.includes('id') && context.id === undefined) {
-        throw new Error(`An id must be provided to the '${path}.${method}' method`);
-    }
-    if (parameters.includes('data') && !commons_1._.isObjectOrArray(context.data)) {
-        throw new Error(`A data object must be provided to the '${path}.${method}' method`);
-    }
-    return next();
-};
-exports.validate = validate;
-//# sourceMappingURL=base.js.map

package/lib/hooks/base.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/hooks/base.ts"],"names":[],"mappings":";;;AAAA,iDAAwC;AAGjC,MAAM,eAAe,GAAG,CAAC,OAAoB,EAAE,IAAS,EAAE,EAAE;IACjE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IACpC,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE3C,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QACxC,OAAe,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;QACnB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;KACrB;IAED,OAAO,IAAI,EAAE,CAAC;AAChB,CAAC,CAAC;AAbW,QAAA,eAAe,mBAa1B;AAEK,MAAM,QAAQ,GAAG,CAAC,OAAoB,EAAE,IAAS,EAAE,EAAE;IAC1D,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;IAC1C,MAAM,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAE3C,IAAI,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,EAAE,KAAK,SAAS,EAAE;QACzD,MAAM,IAAI,KAAK,CAAC,kCAAkC,IAAI,IAAI,MAAM,UAAU,CAAC,CAAC;KAC7E;IAED,IAAI,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,WAAC,CAAC,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;QACnE,MAAM,IAAI,KAAK,CAAC,0CAA0C,IAAI,IAAI,MAAM,UAAU,CAAC,CAAC;KACrF;IAED,OAAO,IAAI,EAAE,CAAC;AAChB,CAAC,CAAC;AAbW,QAAA,QAAQ,YAanB"}

package/lib/hooks/commons.d.ts

@@ -1,20 +0,0 @@
-export declare const ACTIVATE_HOOKS: string | symbol;
-export declare function createHookObject(method: string, data?: any): any;
-export declare function defaultMakeArguments(hook: any): any[];
-export declare function makeArguments(hook: any): any[];
-export declare function convertHookData(obj: any): any;
-export declare function isHookObject(hookObject: any): boolean;
-export declare function getHooks(app: any, service: any, type: string, method: string, appLast?: boolean): any;
-export declare function processHooks(hooks: any[], initialHookObject: any): Promise<any>;
-export declare function enableHooks(obj: any, methods: string[], types: string[]): any;
-export declare function firstHook(context: any, next: any): any;
-export declare function lastHook(context: any, next: any): any;
-export declare function toBeforeHook(hook: any): (context: any, next: any) => Promise<any>;
-export declare function toAfterHook(hook: any): (context: any, next: any) => any;
-export declare function toErrorHook(hook: any, onError: any, control: any): (context: any, next: any) => any;
-export declare function toFinallyHook(hook: any, onError: any, control: any): (context: any, next: any) => any;
-export declare function beforeWrapper(hooks: any): (typeof firstHook)[];
-export declare function afterWrapper(hooks: any): ((context: any, next: any) => any)[];
-export declare function finallyWrapper(hooks: any): ((context: any, next: any) => any)[];
-export declare function errorWrapper(hooks: any): ((context: any, next: any) => any)[];
-export declare function wrap({ async, before, after }?: any): any[];