@feathersjs/feathers 5.0.37 → 6.0.0-pre.0

package/src/hooks.ts

@@ -1,237 +0,0 @@
-import {
-  getManager,
-  HookContextData,
-  HookManager,
-  HookMap as BaseHookMap,
-  hooks,
-  Middleware,
-  collect
-} from '@feathersjs/hooks'
-import {
-  Service,
-  ServiceOptions,
-  HookContext,
-  FeathersService,
-  HookMap,
-  AroundHookFunction,
-  HookFunction,
-  HookType
-} from './declarations'
-import { defaultServiceArguments, getHookMethods } from './service'
-
-type ConvertedMap = { [type in HookType]: ReturnType<typeof convertHookData> }
-
-type HookStore = {
-  around: { [method: string]: AroundHookFunction[] }
-  before: { [method: string]: HookFunction[] }
-  after: { [method: string]: HookFunction[] }
-  error: { [method: string]: HookFunction[] }
-  collected: { [method: string]: AroundHookFunction[] }
-  collectedAll: { before?: AroundHookFunction[]; after?: AroundHookFunction[] }
-}
-
-type HookEnabled = { __hooks: HookStore }
-
-const types: HookType[] = ['before', 'after', 'error', 'around']
-
-const isType = (value: any): value is HookType => types.includes(value)
-
-// 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
-}
-
-export function collectHooks(target: HookEnabled, method: string) {
-  const { collected, collectedAll, around } = target.__hooks
-
-  return [
-    ...(around.all || []),
-    ...(around[method] || []),
-    ...(collectedAll.before || []),
-    ...(collected[method] || []),
-    ...(collectedAll.after || [])
-  ] as AroundHookFunction[]
-}
-
-// Add `.hooks` functionality to an object
-export function enableHooks(object: any) {
-  const store: HookStore = {
-    around: {},
-    before: {},
-    after: {},
-    error: {},
-    collected: {},
-    collectedAll: {}
-  }
-
-  Object.defineProperty(object, '__hooks', {
-    configurable: true,
-    value: store,
-    writable: true
-  })
-
-  return function registerHooks(this: HookEnabled, input: HookMap<any, any>) {
-    const store = this.__hooks
-    const map = Object.keys(input).reduce((map, type) => {
-      if (!isType(type)) {
-        throw new Error(`'${type}' is not a valid hook type`)
-      }
-
-      map[type] = convertHookData(input[type])
-
-      return map
-    }, {} as ConvertedMap)
-    const types = Object.keys(map) as HookType[]
-
-    types.forEach((type) =>
-      Object.keys(map[type]).forEach((method) => {
-        const mapHooks = map[type][method]
-        const storeHooks: any[] = (store[type][method] ||= [])
-
-        storeHooks.push(...mapHooks)
-
-        if (method === 'all') {
-          if (store.before[method] || store.error[method]) {
-            const beforeAll = collect({
-              before: store.before[method] || [],
-              error: store.error[method] || []
-            })
-            store.collectedAll.before = [beforeAll]
-          }
-
-          if (store.after[method]) {
-            const afterAll = collect({
-              after: store.after[method] || []
-            })
-            store.collectedAll.after = [afterAll]
-          }
-        } else {
-          if (store.before[method] || store.after[method] || store.error[method]) {
-            const collected = collect({
-              before: store.before[method] || [],
-              after: store.after[method] || [],
-              error: store.error[method] || []
-            })
-
-            store.collected[method] = [collected]
-          }
-        }
-      })
-    )
-
-    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 as any as HookEnabled, 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: 'around',
-      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)
-
-  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/service.ts

@@ -1,78 +0,0 @@
-import { EventEmitter } from 'events'
-import { createSymbol } from '@feathersjs/commons'
-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 = ['find', 'get', 'create', 'update', 'patch', 'remove']
-
-export const defaultEventMap = {
-  create: 'created',
-  update: 'updated',
-  patch: 'patched',
-  remove: 'removed'
-}
-
-export const defaultServiceEvents = Object.values(defaultEventMap)
-
-export const protectedMethods = Object.keys(Object.prototype)
-  .concat(Object.keys(EventEmitter.prototype))
-  .concat(['all', 'around', 'before', 'after', 'error', 'hooks', 'setup', 'teardown', 'publish'])
-
-export function getHookMethods(service: any, options: ServiceOptions) {
-  const { methods } = options
-
-  return (defaultServiceMethods as any as string[])
-    .filter((m) => typeof service[m] === 'function' && !methods.includes(m))
-    .concat(methods)
-}
-
-export function getServiceOptions(service: any): ServiceOptions {
-  return service[SERVICE]
-}
-
-export const normalizeServiceOptions = (service: any, options: ServiceOptions = {}): ServiceOptions => {
-  const {
-    methods = defaultServiceMethods.filter((method) => typeof service[method] === 'function'),
-    events = service.events || []
-  } = options
-  const serviceEvents = options.serviceEvents || defaultServiceEvents.concat(events)
-
-  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 = normalizeServiceOptions(service, options)
-
-  if (
-    Object.keys(serviceOptions.methods).length === 0 &&
-    ![...defaultServiceMethods, 'setup', 'teardown'].some((method) => typeof service[method] === 'function')
-  ) {
-    throw new Error(`Invalid service object passed for path \`${location}\``)
-  }
-
-  Object.defineProperty(protoService, SERVICE, {
-    value: serviceOptions
-  })
-
-  return protoService
-}

package/src/version.ts

@@ -1 +0,0 @@
-export default '5.0.37'