@feathersjs/transport-commons 5.0.0-pre.9 → 5.0.0

package/src/http.ts

@@ -1,12 +1,12 @@
-import { MethodNotAllowed } from '@feathersjs/errors/lib';
-import { HookContext, NullableId, Params } from '@feathersjs/feathers';
-import { BaseHookContext } from '@feathersjs/hooks';
+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
 }
 
@@ -14,70 +14,82 @@ export const statusCodes = {
   created: 201,
   noContent: 204,
   methodNotAllowed: 405,
-  success: 200
-};
+  success: 200,
+  seeOther: 303
+}
 
-export const knownMethods: { [key: string]: any } = {
+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 getData (context: HookContext|{ [key: string]: any }) {
-  if (!(context instanceof BaseHookContext)) {
-    return context;
+export function getStatusCode(context: HookContext, body: any, location: string | string[]) {
+  const { http = {} } = context
+
+  if (http.status) {
+    return http.status
   }
 
-  return context.dispatch !== undefined
-    ? context.dispatch
-    : context.result;
-}
+  if (context.method === 'create') {
+    return statusCodes.created
+  }
 
-export function getStatusCode (context: HookContext, data?: any) {
-  if (context instanceof BaseHookContext) {
-    if (context.statusCode) {
-      return context.statusCode;
-    }
+  if (location !== undefined) {
+    return statusCodes.seeOther
+  }
 
-    if (context.method === 'create') {
-      return statusCodes.created;
-    }
+  if (!body) {
+    return statusCodes.noContent
   }
 
-  if (!data) {
-    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 }
   }
 
-  return statusCodes.success;
+  const status = getStatusCode(context, body, location)
+
+  return { status, headers, body }
 }

package/src/index.ts

@@ -1,6 +1,7 @@
-import { socket } from './socket';
-import { routing } from './routing';
-import { channels } from './channels';
+import { socket } from './socket'
+import { routing } from './routing'
+import { channels, Channel, CombinedChannel } from './channels'
+import { RealTimeConnection } from '@feathersjs/feathers'
 
-export * as http from './http';
-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,98 +1,136 @@
-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> {
+  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`);
+        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 {
+  remove(path: string[]) {
     if (path.length === this.depth) {
-      return this.data === undefined ? null : {
-        ...info,
-        data: this.data
+      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]
       }
     }
+  }
+
+  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];
+    const current = path[this.depth]
+    const child = this.children[current]
 
     if (child) {
-      return child.lookup(path, info);
+      const lookup = child.lookup(path, info)
+
+      if (lookup !== null) {
+        return lookup
+      }
     }
 
     // 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> {
-  constructor (public root: RouteNode<T> = new RouteNode<T>('', 0)) {}
+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,69 @@
-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, RealTimeConnection } from '@feathersjs/feathers'
+import { createDebug } from '@feathersjs/commons'
+import { channels } from '../channels'
+import { routing } from '../routing'
+import { getDispatcher, runMethod } from './utils'
 
-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]))
+      })
+    )
+  }
 }