@feathersjs/transport-commons 5.0.0-pre.1 → 5.0.0-pre.15

package/src/client.ts

@@ -1,8 +1,8 @@
-import Debug from 'debug';
 import { convert } from '@feathersjs/errors';
-import { Params } from '@feathersjs/feathers';
+import { createDebug } from '@feathersjs/commons';
+import { Id, NullableId, Params, ServiceInterface } from '@feathersjs/feathers';
 
-const debug = Debug('@feathersjs/transport-commons/client');
+const debug = createDebug('@feathersjs/transport-commons/client');
 
 const namespacedEmitterMethods = [
   'addListener',
@@ -59,7 +59,9 @@ interface ServiceOptions {
   events?: string[];
 }
 
-export class Service {
+export type SocketService<T = any, D = Partial<any>> = Service<T, D>;
+
+export class Service<T = any, D = Partial<T>> implements ServiceInterface<T, D> {
   events: string[];
   path: string;
   connection: any;
@@ -74,8 +76,8 @@ export class Service {
     addEmitterMethods(this);
   }
 
-  send (method: string, ...args: any[]) {
-    return new Promise((resolve, reject) => {
+  send<X = any> (method: string, ...args: any[]) {
+    return new Promise<X>((resolve, reject) => {
       args.unshift(method, this.path);
       args.push(function (error: any, data: any) {
         return error ? reject(convert(error)) : resolve(data);
@@ -87,28 +89,37 @@ export class Service {
     });
   }
 
+  methods (this: any, ...names: string[]) {
+    names.forEach(name => {
+      this[name] = function (data: any, params: Params = {}) {
+        return this.send(name, data, params.query || {});
+      }
+    });
+    return this;
+  }
+
   find (params: Params = {}) {
-    return this.send('find', params.query || {});
+    return this.send<T|T[]>('find', params.query || {});
   }
 
-  get (id: number | string, params: Params = {}) {
-    return this.send('get', id, params.query || {});
+  get (id: Id, params: Params = {}) {
+    return this.send<T>('get', id, params.query || {});
   }
 
   create (data: any, params: Params = {}) {
-    return this.send('create', data, params.query || {});
+    return this.send<T>('create', data, params.query || {});
   }
 
-  update (id: number | string, data: any, params: Params = {}) {
-    return this.send('update', id, data, params.query || {});
+  update (id: Id, data: any, params: Params = {}) {
+    return this.send<T> ('update', id, data, params.query || {});
   }
 
-  patch (id: number | string, data: any, params: Params = {}) {
-    return this.send('patch', id, data, params.query || {});
+  patch (id: NullableId, data: any, params: Params = {}) {
+    return this.send<T|T[]> ('patch', id, data, params.query || {});
   }
 
-  remove (id: number | string, params: Params = {}) {
-    return this.send('remove', id, params.query || {});
+  remove (id: NullableId, params: Params = {}) {
+    return this.send<T|T[]> ('remove', id, params.query || {});
   }
 
   // `off` is actually not part of the Node event emitter spec

package/src/http.ts

@@ -0,0 +1,76 @@
+import { MethodNotAllowed } from '@feathersjs/errors/lib';
+import { HookContext, NullableId, Params } from '@feathersjs/feathers';
+
+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
+};
+
+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 getData (context: HookContext) {
+  return context.dispatch !== undefined
+    ? context.dispatch
+    : context.result;
+}
+
+export function getStatusCode (context: HookContext, data?: any) {
+  if (context.http?.statusCode) {
+    return context.http.statusCode;
+  }
+
+  if (context.method === 'create') {
+    return statusCodes.created;
+  }
+
+  if (!data) {
+    return statusCodes.noContent;
+  }
+
+  return statusCodes.success;
+}

package/src/index.ts

@@ -2,4 +2,5 @@ import { socket } from './socket';
 import { routing } from './routing';
 import { channels } from './channels';
 
+export * as http from './http';
 export { socket, routing, channels };

package/src/routing/index.ts

@@ -0,0 +1,50 @@
+import { Application, Service, ServiceOptions } from '@feathersjs/feathers';
+import { Router } from './router';
+
+declare module '@feathersjs/feathers/lib/declarations' {
+  interface RouteLookup {
+    service: Service,
+    params: { [key: string]: any }
+  }
+
+  interface Application<Services, Settings> {  // eslint-disable-line
+    routes: Router<{
+      service: Service,
+      params?: { [key: string]: any }
+    }>;
+    lookup (path: string): RouteLookup;
+  }
+}
+
+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;
+  }
+
+  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;
+
+    app.routes.insert(path, { service, params });
+    app.routes.insert(`${path}/:__id`, { service, params });
+  });
+};

package/src/routing/router.ts

@@ -0,0 +1,98 @@
+import { stripSlashes } from '@feathersjs/commons';
+
+export interface LookupData {
+  params: { [key: string]: string };
+}
+
+export interface LookupResult<T> extends LookupData {
+  data?: T;
+}
+
+export class RouteNode<T = any> {
+  data?: T;
+  children: { [key: string]: RouteNode } = {};
+  placeholders: RouteNode[] = [];
+
+  constructor (public name: string, public depth: number) {}
+
+  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 = 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);
+
+      if (!placeholder) {
+        placeholder = new RouteNode(placeholderName, nextDepth);
+        this.placeholders.push(placeholder);
+      }
+
+      return placeholder.insert(path, data);
+    }
+
+    const child = this.children[current] || new RouteNode(current, nextDepth);
+
+    this.children[current] = child;
+
+    return child.insert(path, data);
+  }
+
+  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(path, 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 = any> {
+  constructor (public root: RouteNode<T> = new RouteNode<T>('', 0)) {}
+
+  getPath (path: string) {
+    return stripSlashes(path).split('/');
+  }
+
+  insert (path: string, data: T) {
+    return this.root.insert(this.getPath(path), data);
+  }
+
+  lookup (path: string) {
+    if (typeof path !== 'string') {
+      return null;
+    }
+
+    return this.root.lookup(this.getPath(path), { params: {} });
+  }
+}

package/src/socket/index.ts

@@ -1,11 +1,11 @@
-import { Application, Params } from '@feathersjs/feathers';
-import Debug from 'debug';
+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 = Debug('@feathersjs/transport-commons');
+const debug = createDebug('@feathersjs/transport-commons');
 
 export interface SocketOptions {
   done: Promise<any>;
@@ -45,28 +45,26 @@ export function socket ({ done, emit, socketMap, socketKey, getParams }: SocketO
 
     // `socket.emit('methodName', 'serviceName', ...args)` handlers
     done.then(provider => provider.on('connection', (connection: any) => {
-      for (const method of app.methods) {
-        connection.on(method, (...args: any[]) => {
-          const path = args.shift();
+      const methodHandlers = Object.keys(app.services).reduce((result, name) => {
+        const { methods } = getServiceOptions(app.service(name));
 
-          debug(`Got '${method}' call for service '${path}'`);
-          runMethod(app, getParams(connection), path, method, args);
+        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);
+            }
+          }
         });
-      }
 
-      connection.on('authenticate', (...args: any[]) => {
-        if (app.get('defaultAuthentication')) {
-          debug('Got legacy authenticate event');
-          runMethod(app, getParams(connection), app.get('defaultAuthentication'), 'create', args);
-        }
-      });
+        return result;
+      }, {} as any);
 
-      connection.on('logout', (callback: any) => {
-        if (app.get('defaultAuthentication')) {
-          debug('Got legacy authenticate event');
-          runMethod(app, getParams(connection), app.get('defaultAuthentication'), 'remove', [ null, {}, callback ]);
-        }
-      });
+      Object.keys(methodHandlers).forEach(key =>
+        connection.on(key, methodHandlers[key])
+      );
     }));
   };
 }

package/src/socket/utils.ts

@@ -1,17 +1,16 @@
-import Debug from 'debug';
+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 { NotFound, MethodNotAllowed } from '@feathersjs/errors';
-import { HookContext, Application } from '@feathersjs/feathers';
 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;
 
 export const paramsPositions: { [key: string]: number } = {
   find: 0,
-  get: 1,
-  remove: 1,
-  create: 1,
   update: 2,
   patch: 2
 };
@@ -62,7 +61,7 @@ export function getDispatcher (emit: string, socketMap: WeakMap<RealTimeConnecti
   };
 }
 
-export function runMethod (app: Application, connection: RealTimeConnection, path: string, method: string, args: any[]) {
+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'
@@ -74,45 +73,42 @@ export function runMethod (app: Application, connection: RealTimeConnection, pat
     debug(`Error in ${trace}`, error);
     callback(normalizeError(error));
   };
-  // A wrapper function that runs the method and returns a promise
-  const _run = () => {
+
+  try {
     const lookup = app.lookup(path);
 
-    // No valid service was found, return a 404
-    // just like a REST route would
+    // No valid service was found throw a NotFound error
     if (lookup === null) {
-      return Promise.reject(new NotFound(`Service '${path}' not found`));
+      throw new NotFound(`Service '${path}' not found`);
     }
 
     const { service, params: route = {} } = lookup;
+    const { methods } = getServiceOptions(service);
 
     // Only service methods are allowed
-    // @ts-ignore
-    if (paramsPositions[method] === undefined || typeof service[method] !== 'function') {
-      return Promise.reject(new MethodNotAllowed(`Method '${method}' not allowed on service '${path}'`));
+    if (!methods.includes(method)) {
+      throw new MethodNotAllowed(`Method '${method}' not allowed on service '${path}'`);
     }
 
-    const position = paramsPositions[method];
+    const position = paramsPositions[method] !== undefined ? paramsPositions[method] : DEFAULT_PARAMS_POSITION;
     const query = methodArgs[position] || {};
-    // `params` have to be re-mapped to the query
-    // and added with the route
+    // `params` have to be re-mapped to the query and added with the route
     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`);
+    }
+
     methodArgs[position] = params;
 
-    // @ts-ignore
-    return service[method](...methodArgs, true);
-  };
+    const ctx = createContext(service, method);
+    const returnedCtx: HookContext = await (service as any)[method](...methodArgs, ctx);
+    const result = returnedCtx.dispatch || returnedCtx.result;
 
-  try {
-    // Run and map to the callback that is being called for Socket calls
-    _run().then((hook: HookContext) => {
-      const result = hook.dispatch || hook.result;
-
-      debug(`Returned successfully ${trace}`, result);
-      callback(null, result);
-    }).catch((hook: HookContext) => handleError(hook.type === 'error' ? hook.error : hook));
-  } catch (error) {
+    debug(`Returned successfully ${trace}`, result);
+    callback(null, result);
+  } catch (error: any) {
     handleError(error);
   }
 }

package/lib/routing.d.ts

@@ -1,10 +0,0 @@
-import { Application } from '@feathersjs/feathers';
-export declare const ROUTER: unique symbol;
-declare module '@feathersjs/feathers/lib/declarations' {
-    interface Application<ServiceTypes> {
-        lookup(path: string): {
-            [key: string]: string;
-        };
-    }
-}
-export declare const routing: () => (app: Application) => void;

package/lib/routing.js

@@ -1,37 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.routing = exports.ROUTER = void 0;
-// @ts-ignore
-const radix_router_1 = __importDefault(require("radix-router"));
-const commons_1 = require("@feathersjs/commons");
-exports.ROUTER = Symbol('@feathersjs/transport-commons/router');
-const routing = () => (app) => {
-    if (typeof app.lookup === 'function') {
-        return;
-    }
-    const router = new radix_router_1.default();
-    Object.assign(app, {
-        [exports.ROUTER]: router,
-        lookup(path) {
-            if (!path) {
-                return null;
-            }
-            return this[exports.ROUTER].lookup(commons_1.stripSlashes('' + path) || '/');
-        }
-    });
-    // Add a mixin that registers a service on the router
-    app.mixins.push((service, path) => {
-        // @ts-ignore
-        app[exports.ROUTER].insert({ path, service });
-        // @ts-ignore
-        app[exports.ROUTER].insert({
-            path: `${path}/:__id`,
-            service
-        });
-    });
-};
-exports.routing = routing;
-//# sourceMappingURL=routing.js.map

package/lib/routing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"routing.js","sourceRoot":"","sources":["../src/routing.ts"],"names":[],"mappings":";;;;;;AAAA,aAAa;AACb,gEAAkC;AAClC,iDAAmD;AAGtC,QAAA,MAAM,GAAG,MAAM,CAAC,sCAAsC,CAAC,CAAC;AAQ9D,MAAM,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC,GAAgB,EAAE,EAAE;IAChD,IAAI,OAAO,GAAG,CAAC,MAAM,KAAK,UAAU,EAAE;QACpC,OAAO;KACR;IAED,MAAM,MAAM,GAAG,IAAI,sBAAM,EAAE,CAAC;IAE5B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;QACjB,CAAC,cAAM,CAAC,EAAE,MAAM;QAChB,MAAM,CAAE,IAAY;YAClB,IAAI,CAAC,IAAI,EAAE;gBACT,OAAO,IAAI,CAAC;aACb;YAED,OAAO,IAAI,CAAC,cAAM,CAAC,CAAC,MAAM,CAAC,sBAAY,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QAC7D,CAAC;KACF,CAAC,CAAC;IAEH,qDAAqD;IACrD,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE;QAChC,aAAa;QACb,GAAG,CAAC,cAAM,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QACtC,aAAa;QACb,GAAG,CAAC,cAAM,CAAC,CAAC,MAAM,CAAC;YACjB,IAAI,EAAE,GAAG,IAAI,QAAQ;YACrB,OAAO;SACR,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AA5BW,QAAA,OAAO,WA4BlB"}

package/src/routing.ts

@@ -1,42 +0,0 @@
-// @ts-ignore
-import Router from 'radix-router';
-import { stripSlashes } from '@feathersjs/commons';
-import { Application } from '@feathersjs/feathers';
-
-export const ROUTER = Symbol('@feathersjs/transport-commons/router');
-
-declare module '@feathersjs/feathers/lib/declarations' {
-  interface Application<ServiceTypes> { // eslint-disable-line
-    lookup (path: string): { [key: string]: string };
-  }
-}
-
-export const routing = () => (app: Application) => {
-  if (typeof app.lookup === 'function') {
-    return;
-  }
-
-  const router = new Router();
-
-  Object.assign(app, {
-    [ROUTER]: router,
-    lookup (path: string): { [key: string]: string } {
-      if (!path) {
-        return null;
-      }
-
-      return this[ROUTER].lookup(stripSlashes('' + path) || '/');
-    }
-  });
-
-  // Add a mixin that registers a service on the router
-  app.mixins.push((service, path) => {
-    // @ts-ignore
-    app[ROUTER].insert({ path, service });
-    // @ts-ignore
-    app[ROUTER].insert({
-      path: `${path}/:__id`,
-      service
-    });
-  });
-};