@feathersjs/transport-commons 5.0.0-pre.3 → 5.0.0-pre.31

package/src/http.ts

@@ -0,0 +1,95 @@
+import { MethodNotAllowed } from '@feathersjs/errors/lib'
+import { HookContext, NullableId, Params } from '@feathersjs/feathers'
+import encodeUrl from 'encodeurl'
+
+export const METHOD_HEADER = 'x-service-method'
+
+export interface ServiceParams {
+  id: NullableId
+  data: any
+  params: Params
+}
+
+export const statusCodes = {
+  created: 201,
+  noContent: 204,
+  methodNotAllowed: 405,
+  success: 200,
+  seeOther: 303
+}
+
+export const knownMethods: { [key: string]: string } = {
+  post: 'create',
+  patch: 'patch',
+  put: 'update',
+  delete: 'remove'
+}
+
+export function getServiceMethod(_httpMethod: string, id: unknown, headerOverride?: string) {
+  const httpMethod = _httpMethod.toLowerCase()
+
+  if (httpMethod === 'post' && headerOverride) {
+    return headerOverride
+  }
+
+  const mappedMethod = knownMethods[httpMethod]
+
+  if (mappedMethod) {
+    return mappedMethod
+  }
+
+  if (httpMethod === 'get') {
+    return id === null ? 'find' : 'get'
+  }
+
+  throw new MethodNotAllowed(`Method ${_httpMethod} not allowed`)
+}
+
+export const argumentsFor = {
+  get: ({ id, params }: ServiceParams) => [id, params],
+  find: ({ params }: ServiceParams) => [params],
+  create: ({ data, params }: ServiceParams) => [data, params],
+  update: ({ id, data, params }: ServiceParams) => [id, data, params],
+  patch: ({ id, data, params }: ServiceParams) => [id, data, params],
+  remove: ({ id, params }: ServiceParams) => [id, params],
+  default: ({ data, params }: ServiceParams) => [data, params]
+}
+
+export function getStatusCode(context: HookContext, body: any, location: string | string[]) {
+  const { http = {} } = context
+
+  if (http.status) {
+    return http.status
+  }
+
+  if (context.method === 'create') {
+    return statusCodes.created
+  }
+
+  if (location !== undefined) {
+    return statusCodes.seeOther
+  }
+
+  if (!body) {
+    return statusCodes.noContent
+  }
+
+  return statusCodes.success
+}
+
+export function getResponse(context: HookContext) {
+  const { http = {} } = context
+  const body = context.dispatch !== undefined ? context.dispatch : context.result
+
+  let headers = http.headers || {}
+  let location = headers.Location
+
+  if (http.location !== undefined) {
+    location = encodeUrl(http.location)
+    headers = { ...headers, Location: location }
+  }
+
+  const status = getStatusCode(context, body, location)
+
+  return { status, headers, body }
+}

package/src/index.ts

@@ -1,5 +1,6 @@
-import { socket } from './socket';
-import { routing } from './routing';
-import { channels } from './channels';
+import { socket } from './socket'
+import { routing } from './routing'
+import { channels, Channel, CombinedChannel, RealTimeConnection } from './channels'
 
-export { socket, routing, channels };
+export * as http from './http'
+export { socket, routing, channels, Channel, CombinedChannel, RealTimeConnection }

package/src/routing/index.ts

@@ -1,45 +1,62 @@
-import { Application, Service } from '@feathersjs/feathers';
-import { Router } from './router';
+import { Application, FeathersService, ServiceOptions } from '@feathersjs/feathers'
+import { Router } from './router'
 
 declare module '@feathersjs/feathers/lib/declarations' {
   interface RouteLookup {
-    service: Service<any>,
-    params: { [key: string]: string }
+    service: Service
+    params: { [key: string]: any }
   }
 
-  interface Application<ServiceTypes, AppSettings> {  // eslint-disable-line
-    routes: Router<any>;
-    lookup (path: string): RouteLookup;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  interface Application<Services, Settings> {
+    // eslint-disable-line
+    routes: Router<{
+      service: Service
+      params?: { [key: string]: any }
+    }>
+    lookup(path: string): RouteLookup
   }
 }
 
-export * from './router';
+export * from './router'
 
-export const routing = () => (app: Application) => {
-  if (typeof app.lookup === 'function') {
-    return;
+const lookup = function (this: Application, path: string) {
+  const result = this.routes.lookup(path)
+
+  if (result === null) {
+    return null
   }
 
-  const routes = new Router();
+  const {
+    params: colonParams,
+    data: { service, params: dataParams }
+  } = result
 
-  Object.assign(app, {
-    routes,
-    lookup (this: Application, path: string) {
-      const result = this.routes.lookup(path);
+  const params = dataParams ? { ...dataParams, ...colonParams } : colonParams
 
-      if (result !== null) {
-        const { params, data: service } = result;
+  return { service, params }
+}
 
-        return { params, service };
-      }
+export const routing = () => (app: Application) => {
+  if (typeof app.lookup === 'function') {
+    return
+  }
+
+  const { unuse } = app
 
-      return result;
-    }
-  });
+  app.routes = new Router()
+  app.lookup = lookup
+  app.unuse = function (path: string) {
+    app.routes.remove(path)
+    app.routes.remove(`${path}/:__id`)
+    return unuse.call(this, path)
+  }
 
   // Add a mixin that registers a service on the router
-  app.mixins.push((service: Service<any>, path: string) => {
-    app.routes.insert(path, service);
-    app.routes.insert(`${path}/:__id`, service);
-  });
-};
+  app.mixins.push((service: FeathersService, path: string, options: ServiceOptions) => {
+    const { routeParams: params = {} } = options
+
+    app.routes.insert(path, { service, params })
+    app.routes.insert(`${path}/:__id`, { service, params })
+  })
+}

package/src/routing/router.ts

@@ -1,87 +1,136 @@
-import { stripSlashes } from '@feathersjs/commons';
-import { BadRequest } from '@feathersjs/errors';
+import { stripSlashes } from '@feathersjs/commons'
 
 export interface LookupData {
-  params: { [key: string]: string };
+  params: { [key: string]: string }
 }
 
 export interface LookupResult<T> extends LookupData {
-  data?: T;
+  data?: T
 }
 
 export class RouteNode<T = any> {
-  data?: T;
-  children: { [key: string]: RouteNode } = {};
-  placeholder?: RouteNode;
+  data?: T
+  children: { [key: string]: RouteNode } = {}
+  placeholders: RouteNode[] = []
 
-  constructor (public name: string) {}
+  constructor(public name: string, public depth: number) {}
 
-  insert (path: string[], data: T): RouteNode<T> {
-    if (path.length === 0) {
-      this.data = data;
-      return this;
+  get hasChildren() {
+    return Object.keys(this.children).length !== 0 || this.placeholders.length !== 0
+  }
+
+  insert(path: string[], data: T): RouteNode<T> {
+    if (this.depth === path.length) {
+      if (this.data !== undefined) {
+        throw new Error(`Path ${path.join('/')} already exists`)
+      }
+
+      this.data = data
+      return this
     }
 
-    const [ current, ...rest ] = path;
+    const current = path[this.depth]
+    const nextDepth = this.depth + 1
 
     if (current.startsWith(':')) {
-      const { placeholder } = this;
-      const name = current.substring(1);
+      // Insert a placeholder node like /messages/:id
+      const placeholderName = current.substring(1)
+      let placeholder = this.placeholders.find((p) => p.name === placeholderName)
 
       if (!placeholder) {
-        this.placeholder = new RouteNode(name);
-      } else if(placeholder.name !== name) {
-        throw new BadRequest(`Can not add route with placeholder ':${name}' because placeholder ':${placeholder.name}' already exists`);
+        placeholder = new RouteNode(placeholderName, nextDepth)
+        this.placeholders.push(placeholder)
       }
 
-      return this.placeholder.insert(rest, data);
+      return placeholder.insert(path, data)
     }
 
-    this.children[current] = this.children[current] || new RouteNode(current);
+    const child = this.children[current] || new RouteNode(current, nextDepth)
+
+    this.children[current] = child
 
-    return this.children[current].insert(rest, data);
+    return child.insert(path, data)
   }
 
-  lookup (path: string[], info: LookupData): LookupResult<T>|null {
-    if (path.length === 0) {
-      return {
-        ...info,
-        data: this.data
+  remove(path: string[]) {
+    if (path.length === this.depth) {
+      return
+    }
+
+    const current = path[this.depth]
+
+    if (current.startsWith(':')) {
+      const placeholderName = current.substring(1)
+      const placeholder = this.placeholders.find((p) => p.name === placeholderName)
+
+      placeholder.remove(path)
+      this.placeholders = this.placeholders.filter((p) => p !== placeholder)
+    } else if (this.children[current]) {
+      const child = this.children[current]
+
+      child.remove(path)
+
+      if (!child.hasChildren) {
+        delete this.children[current]
       }
     }
+  }
 
-    const [ current, ...rest ] = path;
-    const child = this.children[current];
+  lookup(path: string[], info: LookupData): LookupResult<T> | null {
+    if (path.length === this.depth) {
+      return this.data === undefined
+        ? null
+        : {
+            ...info,
+            data: this.data
+          }
+    }
+
+    const current = path[this.depth]
+    const child = this.children[current]
 
     if (child) {
-      return child.lookup(rest, info);
+      const lookup = child.lookup(path, info)
+
+      if (lookup !== null) {
+        return lookup
+      }
     }
 
-    if (this.placeholder) {
-      info.params[this.placeholder.name] = current;
-      return this.placeholder.lookup(rest, info);
+    // This will return the first placeholder that matches early
+    for (const placeholder of this.placeholders) {
+      const result = placeholder.lookup(path, info)
+
+      if (result !== null) {
+        result.params[placeholder.name] = current
+        return result
+      }
     }
 
-    return null;
+    return null
   }
 }
 
-export class Router<T> {
-  root: RouteNode<T> = new RouteNode<T>('');
+export class Router<T = any> {
+  constructor(public root: RouteNode<T> = new RouteNode<T>('', 0)) {}
+
+  getPath(path: string) {
+    return stripSlashes(path).split('/')
+  }
 
-  getPath (path: string) {
-    return stripSlashes(path).split('/');
+  insert(path: string, data: T) {
+    return this.root.insert(this.getPath(path), data)
   }
 
-  insert (path: string, data: T) {
-    return this.root.insert(this.getPath(path), data);
+  remove(path: string) {
+    return this.root.remove(this.getPath(path))
   }
 
-  lookup (path: string) {
+  lookup(path: string) {
     if (typeof path !== 'string') {
-      return null;
+      return null
     }
 
-    return this.root.lookup(this.getPath(path), { params: {} });
+    return this.root.lookup(this.getPath(path), { params: {} })
   }
 }

package/src/socket/index.ts

@@ -1,70 +1,70 @@
-import { Application, getServiceOptions, Params } from '@feathersjs/feathers';
-import { createDebug } from '@feathersjs/commons';
-import { channels } from '../channels';
-import { routing } from '../routing';
-import { getDispatcher, runMethod } from './utils';
-import { RealTimeConnection } from '../channels/channel/base';
+import { Application, getServiceOptions, Params } from '@feathersjs/feathers'
+import { createDebug } from '@feathersjs/commons'
+import { channels } from '../channels'
+import { routing } from '../routing'
+import { getDispatcher, runMethod } from './utils'
+import { RealTimeConnection } from '../channels/channel/base'
 
-const debug = createDebug('@feathersjs/transport-commons');
+const debug = createDebug('@feathersjs/transport-commons')
 
 export interface SocketOptions {
-  done: Promise<any>;
-  emit: string;
-  socketMap: WeakMap<RealTimeConnection, any>;
-  socketKey?: any;
-  getParams: (socket: any) => RealTimeConnection;
+  done: Promise<any>
+  emit: string
+  socketMap: WeakMap<RealTimeConnection, any>
+  socketKey?: any
+  getParams: (socket: any) => RealTimeConnection
 }
 
-export function socket ({ done, emit, socketMap, socketKey, getParams }: SocketOptions) {
+export function socket({ done, emit, socketMap, socketKey, getParams }: SocketOptions) {
   return (app: Application) => {
     const leaveChannels = (connection: RealTimeConnection) => {
-      const { channels } = app;
+      const { channels } = app
 
       if (channels.length) {
-        app.channel(app.channels).leave(connection);
+        app.channel(app.channels).leave(connection)
       }
-    };
+    }
 
-    app.configure(channels());
-    app.configure(routing());
+    app.configure(channels())
+    app.configure(routing())
 
-    app.on('publish', getDispatcher(emit, socketMap, socketKey));
-    app.on('disconnect', leaveChannels);
+    app.on('publish', getDispatcher(emit, socketMap, socketKey))
+    app.on('disconnect', leaveChannels)
     app.on('logout', (_authResult: any, params: Params) => {
-      const { connection } = params;
+      const { connection } = params
 
       if (connection) {
-        leaveChannels(connection);
+        leaveChannels(connection)
       }
-    });
+    })
 
     // `connection` event
-    done.then(provider => provider.on('connection', (connection: any) =>
-      app.emit('connection', getParams(connection)))
-    );
+    done.then((provider) =>
+      provider.on('connection', (connection: any) => app.emit('connection', getParams(connection)))
+    )
 
     // `socket.emit('methodName', 'serviceName', ...args)` handlers
-    done.then(provider => provider.on('connection', (connection: any) => {
-      const methodHandlers = Object.keys(app.services).reduce((result, name) => {
-        const { methods } = getServiceOptions(app.service(name));
+    done.then((provider) =>
+      provider.on('connection', (connection: any) => {
+        const methodHandlers = Object.keys(app.services).reduce((result, name) => {
+          const { methods } = getServiceOptions(app.service(name))
 
-        methods.forEach(method => {
-          if (!result[method]) {
-            result[method] = (...args: any[]) => {
-              const path = args.shift();
+          methods.forEach((method) => {
+            if (!result[method]) {
+              result[method] = (...args: any[]) => {
+                const path = args.shift()
 
-              debug(`Got '${method}' call for service '${path}'`);
-              runMethod(app, getParams(connection), path, method, args);
+                debug(`Got '${method}' call for service '${path}'`)
+                runMethod(app, getParams(connection), path, method, args)
+              }
             }
-          }
-        });
+          })
 
-        return result;
-      }, {} as any);
+          return result
+        }, {} as any)
 
-      Object.keys(methodHandlers).forEach(key =>
-        connection.on(key, methodHandlers[key])
-      );
-    }));
-  };
+        Object.keys(methodHandlers).forEach((key) => connection.on(key, methodHandlers[key]))
+      })
+    )
+  }
 }

package/src/socket/utils.ts

@@ -1,114 +1,121 @@
-import { HookContext, Application, createContext, getServiceOptions } from '@feathersjs/feathers';
-import { NotFound, MethodNotAllowed, BadRequest } from '@feathersjs/errors';
-import { createDebug } from '@feathersjs/commons';
-import isEqual from 'lodash/isEqual';
-import { CombinedChannel } from '../channels/channel/combined';
-import { RealTimeConnection } from '../channels/channel/base';
+import { HookContext, Application, createContext, getServiceOptions } from '@feathersjs/feathers'
+import { NotFound, MethodNotAllowed, BadRequest } from '@feathersjs/errors'
+import { createDebug } from '@feathersjs/commons'
+import isEqual from 'lodash/isEqual'
+import { CombinedChannel } from '../channels/channel/combined'
+import { RealTimeConnection } from '../channels/channel/base'
 
-const debug = createDebug('@feathersjs/transport-commons');
+const debug = createDebug('@feathersjs/transport-commons')
 
-export const DEFAULT_PARAMS_POSITION = 1;
+export const DEFAULT_PARAMS_POSITION = 1
 
 export const paramsPositions: { [key: string]: number } = {
   find: 0,
   update: 2,
   patch: 2
-};
+}
 
-export function normalizeError (e: any) {
-  const hasToJSON = typeof e.toJSON === 'function';
-  const result = hasToJSON ? e.toJSON() : {};
+export function normalizeError(e: any) {
+  const hasToJSON = typeof e.toJSON === 'function'
+  const result = hasToJSON ? e.toJSON() : {}
 
   if (!hasToJSON) {
-    Object.getOwnPropertyNames(e).forEach(key => {
-      result[key] = e[key];
-    });
+    Object.getOwnPropertyNames(e).forEach((key) => {
+      result[key] = e[key]
+    })
   }
 
   if (process.env.NODE_ENV === 'production') {
-    delete result.stack;
+    delete result.stack
   }
 
-  delete result.hook;
+  delete result.hook
 
-  return result;
+  return result
 }
 
-export function getDispatcher (emit: string, socketMap: WeakMap<RealTimeConnection, any>, socketKey?: any) {
+export function getDispatcher(emit: string, socketMap: WeakMap<RealTimeConnection, any>, socketKey?: any) {
   return function (event: string, channel: CombinedChannel, context: HookContext, data?: any) {
-    debug(`Dispatching '${event}' to ${channel.length} connections`);
+    debug(`Dispatching '${event}' to ${channel.length} connections`)
 
-    channel.connections.forEach(connection => {
+    channel.connections.forEach((connection) => {
       // The reference between connection and socket is set in `app.setup`
-      const socket = socketKey ? connection[socketKey] : socketMap.get(connection);
+      const socket = socketKey ? connection[socketKey] : socketMap.get(connection)
 
       if (socket) {
-        const eventName = `${context.path || ''} ${event}`.trim();
+        const eventName = `${context.path || ''} ${event}`.trim()
 
-        let result = channel.dataFor(connection) || context.dispatch || context.result;
+        let result = channel.dataFor(connection) || context.dispatch || context.result
 
         // If we are getting events from an array but try to dispatch individual data
         // try to get the individual item to dispatch from the correct index.
         if (!Array.isArray(data) && Array.isArray(context.result) && Array.isArray(result)) {
-          result = context.result.find(resultData => isEqual(resultData, data));
+          result = context.result.find((resultData) => isEqual(resultData, data))
         }
 
-        debug(`Dispatching '${eventName}' to Socket ${socket.id} with`, result);
+        debug(`Dispatching '${eventName}' to Socket ${socket.id} with`, result)
 
-        socket[emit](eventName, result);
+        socket[emit](eventName, result)
       }
-    });
-  };
+    })
+  }
 }
 
-export async function runMethod (app: Application, connection: RealTimeConnection, path: string, method: string, args: any[]) {
-  const trace = `method '${method}' on service '${path}'`;
-  const methodArgs = args.slice(0);
-  const callback = typeof methodArgs[methodArgs.length - 1] === 'function'
-    ? methodArgs.pop() : function () {};
-
-  debug(`Running ${trace}`, connection, args);
+export async function runMethod(
+  app: Application,
+  connection: RealTimeConnection,
+  path: string,
+  method: string,
+  args: any[]
+) {
+  const trace = `method '${method}' on service '${path}'`
+  const methodArgs = args.slice(0)
+  const callback =
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    typeof methodArgs[methodArgs.length - 1] === 'function' ? methodArgs.pop() : function () {}
+
+  debug(`Running ${trace}`, connection, args)
 
   const handleError = (error: any) => {
-    debug(`Error in ${trace}`, error);
-    callback(normalizeError(error));
-  };
+    debug(`Error in ${trace}`, error)
+    callback(normalizeError(error))
+  }
 
   try {
-    const lookup = app.lookup(path);
+    const lookup = app.lookup(path)
 
     // No valid service was found throw a NotFound error
     if (lookup === null) {
-      throw new NotFound(`Service '${path}' not found`);
+      throw new NotFound(`Service '${path}' not found`)
     }
 
-    const { service, params: route = {} } = lookup;
-    const { methods } = getServiceOptions(service);
+    const { service, params: route = {} } = lookup
+    const { methods } = getServiceOptions(service)
 
     // Only service methods are allowed
     if (!methods.includes(method)) {
-      throw new MethodNotAllowed(`Method '${method}' not allowed on service '${path}'`);
+      throw new MethodNotAllowed(`Method '${method}' not allowed on service '${path}'`)
     }
 
-    const position = paramsPositions[method] !== undefined ? paramsPositions[method] : DEFAULT_PARAMS_POSITION;
-    const query = methodArgs[position] || {};
+    const position = paramsPositions[method] !== undefined ? paramsPositions[method] : DEFAULT_PARAMS_POSITION
+    const query = Object.assign({}, methodArgs[position])
     // `params` have to be re-mapped to the query and added with the route
-    const params = Object.assign({ query, route, connection }, connection);
+    const params = Object.assign({ query, route, connection }, connection)
 
     // `params` is always the last parameter. Error if we got more arguments.
-    if (methodArgs.length > (position + 1)) {
-      throw new BadRequest(`Too many arguments for '${method}' method`);
+    if (methodArgs.length > position + 1) {
+      throw new BadRequest(`Too many arguments for '${method}' method`)
     }
 
-    methodArgs[position] = params;
+    methodArgs[position] = params
 
-    const ctx = createContext(service, method);
-    const returnedCtx: HookContext = await (service as any)[method](...methodArgs, ctx);
-    const result = returnedCtx.dispatch || returnedCtx.result;
+    const ctx = createContext(service, method)
+    const returnedCtx: HookContext = await (service as any)[method](...methodArgs, ctx)
+    const result = returnedCtx.dispatch || returnedCtx.result
 
-    debug(`Returned successfully ${trace}`, result);
-    callback(null, result);
-  } catch (error) {
-    handleError(error);
+    debug(`Returned successfully ${trace}`, result)
+    callback(null, result)
+  } catch (error: any) {
+    handleError(error)
   }
 }