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

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,69 @@
-import { Application, Service } from '@feathersjs/feathers';
-import { Router } from './router';
+import { Application, FeathersService, Service, 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'
+
+const lookup = function (this: Application, path: string) {
+  const result = this.routes.lookup(path)
+
+  if (result === null) {
+    return null
+  }
+
+  const {
+    params: colonParams,
+    data: { service, params: dataParams }
+  } = result
+
+  const params = dataParams ? { ...dataParams, ...colonParams } : colonParams
+
+  return { service, params }
+}
 
 export const routing = () => (app: Application) => {
   if (typeof app.lookup === 'function') {
-    return;
+    return
   }
 
-  const routes = new Router();
-
-  Object.assign(app, {
-    routes,
-    lookup (this: Application, path: string) {
-      const result = this.routes.lookup(path);
+  app.routes = new Router()
+  app.lookup = lookup
 
-      if (result !== null) {
-        const { params, data: service } = result;
+  // This mixin allows us to unregister a service. It needs to run
+  // first so that `teardown` hooks still get registered properly
+  app.mixins.unshift((service: Service) => {
+    const { teardown } = service
 
-        return { params, service };
+    service.teardown = async function (app: Application, path: string) {
+      if (typeof teardown === 'function') {
+        await teardown.call(this, app, path)
       }
-
-      return result;
+      app.routes.remove(path)
+      app.routes.remove(`${path}/:__id`)
     }
-  });
+  })
 
   // 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]))
+      })
+    )
+  }
 }