@feathersjs/transport-commons 5.0.0-pre.2 → 5.0.0-pre.20

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,13 @@
 import { socket } from './socket';
 import { routing } from './routing';
-import { channels } from './channels';
+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,50 @@
-import { Application, Service } from '@feathersjs/feathers';
+import { Application, 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>;
+  interface Application<Services, Settings> {  // eslint-disable-line
+    routes: Router<{
+      service: Service,
+      params?: { [key: string]: any }
+    }>;
     lookup (path: string): RouteLookup;
   }
 }
 
 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;
+  }
 
-      return result;
-    }
-  });
+  app.routes = new Router();
+  app.lookup = lookup;
 
   // 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: Service, 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,5 +1,4 @@
 import { stripSlashes } from '@feathersjs/commons';
-import { BadRequest } from '@feathersjs/errors';
 
 export interface LookupData {
   params: { [key: string]: string };
@@ -12,62 +11,74 @@ export interface LookupResult<T> extends LookupData {
 export class RouteNode<T = any> {
   data?: T;
   children: { [key: string]: RouteNode } = {};
-  placeholder?: 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) {
+    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 {
+    if (path.length === this.depth) {
+      return this.data === undefined ? null : {
         ...info,
         data: this.data
       }
     }
 
-    const [ current, ...rest ] = path;
+    const current = path[this.depth];
     const child = this.children[current];
 
     if (child) {
-      return child.lookup(rest, info);
+      return child.lookup(path, info);
     }
 
-    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;
   }
 }
 
-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('/');

package/src/socket/index.ts

@@ -1,11 +1,11 @@
 import { Application, getServiceOptions, Params } from '@feathersjs/feathers';
-import Debug from 'debug';
+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 = Debug('@feathersjs/transport-commons');
+const debug = createDebug('@feathersjs/transport-commons');
 
 export interface SocketOptions {
   done: Promise<any>;

package/src/socket/utils.ts

@@ -1,11 +1,11 @@
-import Debug from 'debug';
-import isEqual from 'lodash/isEqual';
-import { NotFound, MethodNotAllowed, BadRequest } from '@feathersjs/errors';
 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 = Debug('@feathersjs/transport-commons');
+const debug = createDebug('@feathersjs/transport-commons');
 
 export const DEFAULT_PARAMS_POSITION = 1;
 
@@ -91,7 +91,7 @@ export async function runMethod (app: Application, connection: RealTimeConnectio
     }
 
     const position = paramsPositions[method] !== undefined ? paramsPositions[method] : DEFAULT_PARAMS_POSITION;
-    const query = methodArgs[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);
 
@@ -108,7 +108,7 @@ export async function runMethod (app: Application, connection: RealTimeConnectio
 
     debug(`Returned successfully ${trace}`, result);
     callback(null, result);
-  } catch (error) {
+  } catch (error: any) {
     handleError(error);
   }
 }