@feathersjs/feathers 5.0.0-pre.20 → 5.0.0-pre.23

package/src/hooks.ts

@@ -0,0 +1,230 @@
+import {
+  getManager,
+  HookContextData,
+  HookManager,
+  HookMap as BaseHookMap,
+  hooks,
+  Middleware,
+  collect
+} from '@feathersjs/hooks'
+import {
+  Service,
+  ServiceOptions,
+  HookContext,
+  FeathersService,
+  HookMap,
+  AroundHookFunction,
+  HookFunction
+} from './declarations'
+import { defaultServiceArguments, defaultServiceMethods, getHookMethods } from './service'
+
+export function collectHooks(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]: HookFunction[] | AroundHookFunction[] } = {}
+
+  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 HookTypes = 'before' | 'after' | 'error' | 'around'
+
+type ConvertedMap = { [type in HookTypes]: ReturnType<typeof convertHookData> }
+
+type HookStore = {
+  around: { [method: string]: AroundHookFunction[] }
+  before: { [method: string]: HookFunction[] }
+  after: { [method: string]: HookFunction[] }
+  error: { [method: string]: HookFunction[] }
+  hooks: { [method: string]: AroundHookFunction[] }
+}
+
+const types: HookTypes[] = ['before', 'after', 'error', 'around']
+
+const isType = (value: any): value is HookTypes => types.includes(value)
+
+const createMap = (input: HookMap<any, any>, methods: string[]) => {
+  const map = {} as ConvertedMap
+
+  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) && !defaultServiceMethods.includes(method)) {
+        throw new Error(`'${method}' is not a valid hook method`)
+      }
+    })
+
+    map[type] = data
+  })
+
+  return map
+}
+
+const updateStore = (store: HookStore, map: ConvertedMap) =>
+  Object.keys(store.hooks).forEach((method) => {
+    Object.keys(map).forEach((key) => {
+      const type = key as HookTypes
+      const allHooks = map[type].all || []
+      const methodHooks = map[type][method] || []
+
+      if (allHooks.length || methodHooks.length) {
+        const list = [...allHooks, ...methodHooks] as any
+        const hooks = (store[type][method] ||= [])
+
+        hooks.push(...list)
+      }
+    })
+
+    const collected = collect({
+      before: store.before[method] || [],
+      after: store.after[method] || [],
+      error: store.error[method] || []
+    })
+
+    store.hooks[method] = [...(store.around[method] || []), collected]
+  })
+
+// Add `.hooks` functionality to an object
+export function enableHooks(object: any, methods: string[] = defaultServiceMethods) {
+  const store: HookStore = {
+    around: {},
+    before: {},
+    after: {},
+    error: {},
+    hooks: {}
+  }
+
+  for (const method of methods) {
+    store.hooks[method] = []
+  }
+
+  Object.defineProperty(object, '__hooks', {
+    configurable: true,
+    value: store,
+    writable: true
+  })
+
+  return function registerHooks(this: any, input: HookMap<any, any>) {
+    const store = this.__hooks
+    const map = createMap(input, methods)
+
+    updateStore(store, map)
+
+    return this
+  }
+}
+
+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}`)
+  }
+
+  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 appHooks = collectHooks(this.app, this.method)
+    const middleware = super.collectMiddleware(self, args)
+    const methodHooks = collectHooks(self, this.method)
+
+    return [...appHooks, ...middleware, ...methodHooks]
+  }
+
+  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 hookMethods = getHookMethods(service, options)
+
+  const serviceMethodHooks = hookMethods.reduce((res, method) => {
+    const params = (defaultServiceArguments as any)[method] || ['data', 'params']
+
+    res[method] = new FeathersHookManager<A>(this, method).params(...params).props({
+      app: this,
+      path,
+      method,
+      service,
+      event: null,
+      type: null,
+      get statusCode() {
+        return this.http?.status
+      },
+      set statusCode(value: number) {
+        this.http = this.http || {}
+        this.http.status = value
+      }
+    })
+
+    return res
+  }, {} as BaseHookMap)
+
+  const registerHooks = enableHooks(service, hookMethods)
+
+  hooks(service, serviceMethodHooks)
+
+  service.hooks = function (this: any, hookOptions: any) {
+    if (hookOptions.before || hookOptions.after || hookOptions.error || hookOptions.around) {
+      return registerHooks.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/index.ts

@@ -1,19 +1,20 @@
-import { setDebug } from './dependencies';
-import version from './version';
-import { Feathers } from './application';
-import { Application } from './declarations';
+import { setDebug } from '@feathersjs/commons'
 
-export function feathers<T = any, S = any> () {
-  return new Feathers<T, S>() as Application<T, S>;
+import version from './version'
+import { Feathers } from './application'
+import { Application } from './declarations'
+
+export function feathers<T = any, S = any>() {
+  return new Feathers<T, S>() as Application<T, S>
 }
 
-feathers.setDebug = setDebug;
+feathers.setDebug = setDebug
 
-export { version, Feathers };
-export * from './hooks/index';
-export * from './declarations';
-export * from './service';
+export { version, Feathers }
+export * from './hooks'
+export * from './declarations'
+export * from './service'
 
 if (typeof module !== 'undefined') {
-  module.exports = Object.assign(feathers, module.exports);
+  module.exports = Object.assign(feathers, module.exports)
 }

package/src/service.ts

@@ -1,18 +1,19 @@
-import { createSymbol, EventEmitter } from './dependencies';
-import { ServiceOptions } from './declarations';
+import { EventEmitter } from 'events'
+import { createSymbol } from '@feathersjs/commons'
+import { ServiceOptions } from './declarations'
 
-export const SERVICE = createSymbol('@feathersjs/service');
+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' ]
+  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 defaultServiceMethods = Object.keys(defaultServiceArguments)
 
 export const defaultEventMap = {
   create: 'created',
@@ -23,70 +24,53 @@ export const defaultEventMap = {
 
 export const protectedMethods = Object.keys(Object.prototype)
   .concat(Object.keys(EventEmitter.prototype))
-  .concat([
-    'all',
-    'before',
-    'after',
-    'error',
-    'hooks',
-    'setup',
-    'teardown',
-    'publish'
-  ]);
-
-export function getHookMethods (service: any, options: ServiceOptions) {
-  const { methods } = options;
-
-  return defaultServiceMethods.filter(m =>
-    typeof service[m] === 'function' && !methods.includes(m)
-  ).concat(methods);
+  .concat(['all', 'around', 'before', 'after', 'error', 'hooks', 'setup', 'teardown', '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];
+export function getServiceOptions(service: any, options: ServiceOptions = {}): ServiceOptions {
+  const existingOptions = service[SERVICE]
 
   if (existingOptions) {
-    return existingOptions;
+    return existingOptions
   }
 
   const {
-    methods = defaultServiceMethods.filter(method =>
-      typeof service[method] === 'function'
-    ),
+    methods = defaultServiceMethods.filter((method) => typeof service[method] === 'function'),
     events = service.events || []
-  } = options;
-  const {
-    serviceEvents = Object.values(defaultEventMap).concat(events)
-  } = options;
+  } = options
+  const { serviceEvents = Object.values(defaultEventMap).concat(events) } = options
 
   return {
     ...options,
     events,
     methods,
     serviceEvents
-  };
+  }
 }
 
-export function wrapService (
-  location: string, service: any, options: ServiceOptions
-) {
+export function wrapService(location: string, service: any, options: ServiceOptions) {
   // Do nothing if this is already an initialized
   if (service[SERVICE]) {
-    return service;
+    return service
   }
 
-  const protoService = Object.create(service);
-  const serviceOptions = getServiceOptions(service, options);
+  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}\``);
+    throw new Error(`Invalid service object passed for path \`${location}\``)
   }
 
   Object.defineProperty(protoService, SERVICE, {
     value: serviceOptions
-  });
+  })
 
-  return protoService;
+  return protoService
 }

package/src/version.ts

@@ -1 +1 @@
-export default '5.0.0-pre.20';
+export default '5.0.0-pre.23';

package/lib/dependencies.d.ts

@@ -1,4 +0,0 @@
-import { EventEmitter } from 'events';
-export * from '@feathersjs/commons';
-export * from '@feathersjs/hooks';
-export { EventEmitter };

package/lib/dependencies.js

@@ -1,22 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventEmitter = void 0;
-const events_1 = require("events");
-Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return events_1.EventEmitter; } });
-__exportStar(require("@feathersjs/commons"), exports);
-__exportStar(require("@feathersjs/hooks"), exports);
-//# sourceMappingURL=dependencies.js.map

package/lib/dependencies.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dependencies.js","sourceRoot":"","sources":["../src/dependencies.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,mCAAsC;AAI7B,6FAJA,qBAAY,OAIA;AAHrB,sDAAoC;AACpC,oDAAkC"}

package/lib/hooks/index.d.ts

@@ -1,13 +0,0 @@
-import { HookContextData, HookManager, Middleware } from '../dependencies';
-import { Service, ServiceOptions, HookContext, FeathersService, Application } from '../declarations';
-export { fromBeforeHook, fromBeforeHooks, fromAfterHook, fromAfterHooks, fromErrorHook, fromErrorHooks } from './regular';
-export declare function createContext(service: Service, method: string, data?: HookContextData): HookContext<Application<any, any>, any>;
-export declare class FeathersHookManager<A> extends HookManager {
-    app: A;
-    method: string;
-    constructor(app: A, method: string);
-    collectMiddleware(self: any, args: any[]): Middleware[];
-    initializeContext(self: any, args: any[], context: HookContext): import("@feathersjs/hooks/types/base").HookContext<any, any>;
-    middleware(mw: Middleware[]): this;
-}
-export declare function hookMixin<A>(this: A, service: FeathersService<A>, path: string, options: ServiceOptions): FeathersService<A, Service<any, Partial<any>, import("../declarations").Params<import("../declarations").Query>>>;

package/lib/hooks/index.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hookMixin = exports.FeathersHookManager = exports.createContext = exports.fromErrorHooks = exports.fromErrorHook = exports.fromAfterHooks = exports.fromAfterHook = exports.fromBeforeHooks = exports.fromBeforeHook = void 0;
-const dependencies_1 = require("../dependencies");
-const service_1 = require("../service");
-const regular_1 = require("./regular");
-var regular_2 = require("./regular");
-Object.defineProperty(exports, "fromBeforeHook", { enumerable: true, get: function () { return regular_2.fromBeforeHook; } });
-Object.defineProperty(exports, "fromBeforeHooks", { enumerable: true, get: function () { return regular_2.fromBeforeHooks; } });
-Object.defineProperty(exports, "fromAfterHook", { enumerable: true, get: function () { return regular_2.fromAfterHook; } });
-Object.defineProperty(exports, "fromAfterHooks", { enumerable: true, get: function () { return regular_2.fromAfterHooks; } });
-Object.defineProperty(exports, "fromErrorHook", { enumerable: true, get: function () { return regular_2.fromErrorHook; } });
-Object.defineProperty(exports, "fromErrorHooks", { enumerable: true, get: function () { return regular_2.fromErrorHooks; } });
-function createContext(service, method, data = {}) {
-    const createContext = service[method].createContext;
-    if (typeof createContext !== 'function') {
-        throw new Error(`Can not create context for method ${method}`);
-    }
-    return createContext(data);
-}
-exports.createContext = createContext;
-class FeathersHookManager extends dependencies_1.HookManager {
-    constructor(app, method) {
-        super();
-        this.app = app;
-        this.method = method;
-        this._middleware = [];
-    }
-    collectMiddleware(self, args) {
-        const app = this.app;
-        const appHooks = app.appHooks[dependencies_1.HOOKS].concat(app.appHooks[this.method] || []);
-        const regularAppHooks = (0, regular_1.collectRegularHooks)(this.app, this.method);
-        const middleware = super.collectMiddleware(self, args);
-        const regularHooks = (0, regular_1.collectRegularHooks)(self, this.method);
-        return [...appHooks, ...regularAppHooks, ...middleware, ...regularHooks];
-    }
-    initializeContext(self, args, context) {
-        const ctx = super.initializeContext(self, args, context);
-        ctx.params = ctx.params || {};
-        return ctx;
-    }
-    middleware(mw) {
-        this._middleware.push(...mw);
-        return this;
-    }
-}
-exports.FeathersHookManager = FeathersHookManager;
-function hookMixin(service, path, options) {
-    if (typeof service.hooks === 'function') {
-        return service;
-    }
-    const app = this;
-    const hookMethods = (0, service_1.getHookMethods)(service, options);
-    const serviceMethodHooks = hookMethods.reduce((res, method) => {
-        const params = service_1.defaultServiceArguments[method] || ['data', 'params'];
-        res[method] = new FeathersHookManager(app, method)
-            .params(...params)
-            .props({
-            app,
-            path,
-            method,
-            service,
-            event: null,
-            type: null,
-            get statusCode() {
-                var _a;
-                return (_a = this.http) === null || _a === void 0 ? void 0 : _a.status;
-            },
-            set statusCode(value) {
-                (this.http || (this.http = {})).status = value;
-            }
-        });
-        return res;
-    }, {});
-    const handleRegularHooks = (0, regular_1.enableRegularHooks)(service, hookMethods);
-    (0, dependencies_1.hooks)(service, serviceMethodHooks);
-    service.hooks = function (hookOptions) {
-        if (hookOptions.before || hookOptions.after || hookOptions.error) {
-            return handleRegularHooks.call(this, hookOptions);
-        }
-        if (Array.isArray(hookOptions)) {
-            return (0, dependencies_1.hooks)(this, hookOptions);
-        }
-        Object.keys(hookOptions).forEach(method => {
-            const manager = (0, dependencies_1.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;
-}
-exports.hookMixin = hookMixin;
-//# sourceMappingURL=index.js.map

package/lib/hooks/index.js.map

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

package/lib/hooks/regular.d.ts

@@ -1,12 +0,0 @@
-import { HookFunction, RegularHookFunction, RegularHookMap } from '../declarations';
-export declare function fromBeforeHook<A, S>(hook: RegularHookFunction<A, S>): HookFunction<A, S>;
-export declare function fromAfterHook<A, S>(hook: RegularHookFunction<A, S>): HookFunction<A, S>;
-export declare function fromErrorHook<A, S>(hook: RegularHookFunction<A, S>): HookFunction<A, S>;
-export declare function fromBeforeHooks<A, S>(hooks: RegularHookFunction<A, S>[]): HookFunction<unknown, unknown>;
-export declare function fromAfterHooks<A, S>(hooks: RegularHookFunction<A, S>[]): HookFunction<unknown, unknown>;
-export declare function fromErrorHooks<A, S>(hooks: RegularHookFunction<A, S>[]): HookFunction<unknown, unknown>;
-export declare function collectRegularHooks(target: any, method: string): any;
-export declare function convertHookData(input: any): {
-    [method: string]: RegularHookFunction<import("../declarations").Application<any, any>, import("../declarations").Service<any, Partial<any>, import("../declarations").Params<import("../declarations").Query>>>[];
-};
-export declare function enableRegularHooks(object: any, methods?: string[]): (this: any, input: RegularHookMap<any, any>) => any;