@feathersjs/transport-commons 5.0.0-pre.21 → 5.0.0-pre.24

package/src/http.ts

@@ -1,12 +1,12 @@
-import { MethodNotAllowed } from '@feathersjs/errors/lib';
-import { HookContext, NullableId, Params } from '@feathersjs/feathers';
-import encodeUrl from 'encodeurl';
+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 const METHOD_HEADER = 'x-service-method'
 
 export interface ServiceParams {
-  id: NullableId,
-  data: any,
+  id: NullableId
+  data: any
   params: Params
 }
 
@@ -16,80 +16,80 @@ export const statusCodes = {
   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();
+export function getServiceMethod(_httpMethod: string, id: unknown, headerOverride?: string) {
+  const httpMethod = _httpMethod.toLowerCase()
 
   if (httpMethod === 'post' && headerOverride) {
-    return headerOverride;
+    return headerOverride
   }
 
-  const mappedMethod = knownMethods[httpMethod];
+  const mappedMethod = knownMethods[httpMethod]
 
   if (mappedMethod) {
-    return mappedMethod;
+    return mappedMethod
   }
 
   if (httpMethod === 'get') {
-    return id === null ? 'find' : 'get';
+    return id === null ? 'find' : 'get'
   }
 
-  throw new MethodNotAllowed(`Method ${_httpMethod} not allowed`);
+  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 ]
+  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;
+export function getStatusCode(context: HookContext, body: any, location: string | string[]) {
+  const { http = {} } = context
 
   if (http.status) {
-    return http.status;
+    return http.status
   }
 
   if (context.method === 'create') {
-    return statusCodes.created;
+    return statusCodes.created
   }
 
   if (location !== undefined) {
-    return statusCodes.seeOther;
+    return statusCodes.seeOther
   }
 
   if (!body) {
-    return statusCodes.noContent;
+    return statusCodes.noContent
   }
 
-  return statusCodes.success;
+  return statusCodes.success
 }
 
-export function getResponse (context: HookContext) {
-  const { http = {} } = context;
-  const body = context.dispatch !== undefined ? context.dispatch : context.result;
+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;
+  let headers = http.headers || {}
+  let location = headers.Location
 
   if (http.location !== undefined) {
-    location = encodeUrl(http.location);
-    headers = { ...headers, Location: location };
+    location = encodeUrl(http.location)
+    headers = { ...headers, Location: location }
   }
 
-  const status = getStatusCode(context, body, location);
+  const status = getStatusCode(context, body, location)
 
-  return { status, headers, body };
+  return { status, headers, body }
 }

package/src/index.ts

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

package/src/routing/index.ts

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

package/src/routing/router.ts

@@ -1,98 +1,100 @@
-import { stripSlashes } from '@feathersjs/commons';
+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 } = {};
-  placeholders: RouteNode[] = [];
+  data?: T
+  children: { [key: string]: RouteNode } = {}
+  placeholders: RouteNode[] = []
 
-  constructor (public name: string, public depth: number) {}
+  constructor(public name: string, public depth: number) {}
 
-  insert (path: string[], data: T): RouteNode<T> {
+  insert(path: string[], data: T): RouteNode<T> {
     if (this.depth === path.length) {
       if (this.data !== undefined) {
-        throw new Error(`Path ${path.join('/')} already exists`);
+        throw new Error(`Path ${path.join('/')} already exists`)
       }
 
-      this.data = data;
-      return this;
+      this.data = data
+      return this
     }
 
-    const current = path[this.depth];
-    const nextDepth = this.depth + 1;
+    const current = path[this.depth]
+    const nextDepth = this.depth + 1
 
     if (current.startsWith(':')) {
       // Insert a placeholder node like /messages/:id
-      const placeholderName = current.substring(1);
-      let placeholder = this.placeholders.find(p => p.name === placeholderName);
+      const placeholderName = current.substring(1)
+      let placeholder = this.placeholders.find((p) => p.name === placeholderName)
 
       if (!placeholder) {
-        placeholder = new RouteNode(placeholderName, nextDepth);
-        this.placeholders.push(placeholder);
+        placeholder = new RouteNode(placeholderName, nextDepth)
+        this.placeholders.push(placeholder)
       }
 
-      return placeholder.insert(path, data);
+      return placeholder.insert(path, data)
     }
 
-    const child = this.children[current] || new RouteNode(current, nextDepth);
+    const child = this.children[current] || new RouteNode(current, nextDepth)
 
-    this.children[current] = child;
+    this.children[current] = child
 
-    return child.insert(path, data);
+    return child.insert(path, data)
   }
 
-  lookup (path: string[], info: LookupData): LookupResult<T>|null {
+  lookup(path: string[], info: LookupData): LookupResult<T> | null {
     if (path.length === this.depth) {
-      return this.data === undefined ? null : {
-        ...info,
-        data: this.data
-      }
+      return this.data === undefined
+        ? null
+        : {
+            ...info,
+            data: this.data
+          }
     }
 
-    const current = path[this.depth];
-    const child = this.children[current];
+    const current = path[this.depth]
+    const child = this.children[current]
 
     if (child) {
-      return child.lookup(path, info);
+      return child.lookup(path, info)
     }
 
     // This will return the first placeholder that matches early
-    for(const placeholder of this.placeholders) {
-      const result = placeholder.lookup(path, info);
+    for (const placeholder of this.placeholders) {
+      const result = placeholder.lookup(path, info)
 
       if (result !== null) {
-        result.params[placeholder.name] = current;
-        return result;
+        result.params[placeholder.name] = current
+        return result
       }
     }
 
-    return null;
+    return null
   }
 }
 
 export class Router<T = any> {
-  constructor (public root: RouteNode<T> = new RouteNode<T>('', 0)) {}
+  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)
   }
 
-  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 = Object.assign({}, 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);
+    debug(`Returned successfully ${trace}`, result)
+    callback(null, result)
   } catch (error: any) {
-    handleError(error);
+    handleError(error)
   }
 }