@feathersjs/express 5.0.0-pre.2 → 5.0.0-pre.20

package/src/index.ts

@@ -1,25 +1,18 @@
-import Debug from 'debug';
-import express, {
-  Express, static as _static, json, raw, text, urlencoded, query
-} from 'express';
-import {
-  Application as FeathersApplication, defaultServiceMethods
-} from '@feathersjs/feathers';
+import express, { Express } from 'express';
+import { Application as FeathersApplication, defaultServiceMethods } from '@feathersjs/feathers';
+import { routing } from '@feathersjs/transport-commons';
+import { createDebug } from '@feathersjs/commons';
 
 import { Application } from './declarations';
-import { errorHandler, notFound } from './handlers';
-import { parseAuthentication, authenticate } from './authentication';
 
-export {
-  _static as static, json, raw, text, urlencoded, query,
-  errorHandler, notFound, express as original,
-  authenticate, parseAuthentication
-};
+export { default as original, static, static as serveStatic, json, raw, text, urlencoded, query } from 'express';
 
-export * from './rest';
+export * from './authentication';
 export * from './declarations';
+export * from './handlers';
+export * from './rest';
 
-const debug = Debug('@feathersjs/express');
+const debug = createDebug('@feathersjs/express');
 
 export default function feathersExpress<S = any, C = any> (feathersApp?: FeathersApplication<S, C>, expressApp: Express = express()): Application<S, C> {
   if (!feathersApp) {
@@ -30,10 +23,12 @@ export default function feathersExpress<S = any, C = any> (feathersApp?: Feather
     throw new Error('@feathersjs/express requires a valid Feathers application instance');
   }
 
-  const { use, listen } = expressApp as any;
-  // A mixin that provides the extended functionality
-  const mixin: any = {
-    use (location: string, ...rest: any[]) {
+  const app = expressApp as any as Application<S, C>;
+  const { use: expressUse, listen: expressListen } = expressApp as any;
+  const { use: feathersUse, teardown: feathersTeardown } = feathersApp;
+
+  Object.assign(app, {
+    use (location: string & keyof S, ...rest: any[]) {
       let service: any;
       let options = {};
 
@@ -60,46 +55,63 @@ export default function feathersExpress<S = any, C = any> (feathersApp?: Feather
       // Check for service (any object with at least one service method)
       if (hasMethod(['handle', 'set']) || !hasMethod(defaultServiceMethods)) {
         debug('Passing app.use call to Express app');
-        return use.call(this, location, ...rest);
+        return expressUse.call(this, location, ...rest);
       }
 
       debug('Registering service with middleware', middleware);
       // Since this is a service, call Feathers `.use`
-      (feathersApp as FeathersApplication).use.call(this, location, service, {
+      feathersUse.call(this, location, service, {
         ...options,
-        middleware
+        express: middleware
       });
 
       return this;
     },
 
     async listen (...args: any[]) {
-      const server = listen.call(this, ...args);
+      const server = expressListen.call(this, ...args);
 
+      this.server = server;
       await this.setup(server);
       debug('Feathers application listening');
 
       return server;
+    },
+
+    async teardown (server?: any) {
+      return feathersTeardown.call(this, server).then(() =>
+        new Promise((resolve, reject) => this.server.close(e => e ? reject(e) : resolve(this)))
+      );
     }
-  };
+  } as Application<S, C>);
 
-  const feathersDescriptors = {
+  const appDescriptors = {
+    ...Object.getOwnPropertyDescriptors(Object.getPrototypeOf(app)),
+    ...Object.getOwnPropertyDescriptors(app)
+  };
+  const newDescriptors = {
     ...Object.getOwnPropertyDescriptors(Object.getPrototypeOf(feathersApp)),
     ...Object.getOwnPropertyDescriptors(feathersApp)
   };
 
   // Copy all non-existing properties (including non-enumerables)
   // that don't already exist on the Express app
-  Object.keys(feathersDescriptors).forEach(prop => {
-    const feathersProp = feathersDescriptors[prop];
-    const expressProp = Object.getOwnPropertyDescriptor(expressApp, prop);
+  Object.keys(newDescriptors).forEach(prop => {
+    const appProp = appDescriptors[prop];
+    const newProp = newDescriptors[prop];
 
-    if (expressProp === undefined && feathersProp !== undefined) {
-      Object.defineProperty(expressApp, prop, feathersProp);
+    if (appProp === undefined && newProp !== undefined) {
+      Object.defineProperty(expressApp, prop, newProp);
     }
   });
 
-  return Object.assign(expressApp, mixin);
+  app.configure(routing() as any);
+  app.use((req, _res, next) => {
+    req.feathers = { ...req.feathers, provider: 'rest' };
+    return next();
+  });
+
+  return app;
 }
 
 if (typeof module !== 'undefined') {

package/src/rest.ts

@@ -1,160 +1,110 @@
-import Debug from 'debug';
+import { Request, Response, RequestHandler, Router } from 'express';
 import { MethodNotAllowed } from '@feathersjs/errors';
-import { HookContext } from '@feathersjs/hooks';
-import { createContext, defaultServiceMethods, getServiceOptions, NullableId, Params } from '@feathersjs/feathers';
-import { Request, Response, NextFunction, RequestHandler, Router } from 'express';
+import { createDebug } from '@feathersjs/commons';
+import { http } from '@feathersjs/transport-commons';
+import { createContext, defaultServiceMethods, getServiceOptions } from '@feathersjs/feathers';
 
-import { parseAuthentication } from './authentication';
+import { AuthenticationSettings, parseAuthentication } from './authentication';
+import { Application } from './declarations';
 
-const debug = Debug('@feathersjs/express/rest');
+const debug = createDebug('@feathersjs/express/rest');
 
-export const METHOD_HEADER = 'x-service-method';
-
-export interface ServiceParams {
-  id: NullableId,
-  data: any,
-  params: Params
-}
-
-export type ServiceCallback = (req: Request, res: Response, options: ServiceParams) => Promise<HookContext|any>;
-
-export const statusCodes = {
-  created: 201,
-  noContent: 204,
-  methodNotAllowed: 405,
-  success: 200
+const toHandler = (func: (req: Request, res: Response, next: () => void) => Promise<void>): RequestHandler => {
+  return (req, res, next) => func(req, res, next).catch(error => next(error));
 };
 
-export const feathersParams = (req: Request, _res: Response, next: NextFunction) => {
-  req.feathers = {
-    ...req.feathers,
-    provider: 'rest',
-    headers: req.headers
-  };
-  next();
-}
-
-export const formatter = (_req: Request, res: Response, next: NextFunction) => {
-  if (res.data === undefined) {
-    return next();
-  }
-
-  res.format({
-    'application/json' () {
-      res.json(res.data);
-    }
-  });
-}
+const serviceMiddleware = (): RequestHandler => {
+  return toHandler(async (req, res, next) => {
+    const { query, headers, path, body: data, method: httpMethod } = req;
+    const methodOverride = req.headers[http.METHOD_HEADER] as string | undefined;
 
-const getData = (context: HookContext) => {
-  if (!(context instanceof HookContext)) {
-    return context;
-  }
+    const { service, params: { __id: id = null, ...route } = {} } = req.lookup!;
+    const method = http.getServiceMethod(httpMethod, id, methodOverride);
+    const { methods } = getServiceOptions(service);
 
-  return context.dispatch !== undefined
-    ? context.dispatch
-    : context.result;
-}
+    debug(`Found service for path ${path}, attempting to run '${method}' service method`);
 
-const getStatusCode = (context: HookContext, res: Response) => {
-  if (context instanceof HookContext) {
-    if (context.statusCode) {
-      return context.statusCode;
+    if (!methods.includes(method) || defaultServiceMethods.includes(methodOverride)) {
+      const error = new MethodNotAllowed(`Method \`${method}\` is not supported by this endpoint.`);
+      res.statusCode = error.code;
+      throw error;
     }
 
-    if (context.method === 'create') {
-      return statusCodes.created;
-    }
-  }
-
-  if (!res.data) {
-    return statusCodes.noContent;
-  }
+    const createArguments = http.argumentsFor[method as 'get'] || http.argumentsFor.default;
+    const params = { query, headers, route, ...req.feathers };
+    const args = createArguments({ id, data, params });
+    const contextBase = createContext(service, method, { http: {} });
+    res.hook = contextBase;
 
-  return statusCodes.success;
-}
+    const context = await (service as any)[method](...args, contextBase);
+    res.hook = context;
 
-export const serviceMiddleware = (callback: ServiceCallback) =>
-  async (req: Request, res: Response, next: NextFunction) => {
-    debug(`Running service middleware for '${req.url}'`);
+    const response = http.getResponse(context);
+    res.statusCode = response.status;
+    res.set(response.headers);
+    res.data = response.body;
 
-    try {
-      const { query, body: data } = req;
-      const { __feathersId: id = null, ...route } = req.params;
-      const params = { query, route, ...req.feathers };
-      const context = await callback(req, res, { id, data, params });
+    return next();
+  });
+};
 
-      res.data = getData(context);
-      res.status(getStatusCode(context, res));
+const servicesMiddleware = (): RequestHandler => {
+  return toHandler(async (req, res, next) => {
+    const app = req.app as any as Application;
+    const lookup = app.lookup(req.path);
 
-      next();
-    } catch (error) {
-      next(error);
+    if (!lookup) {
+      return next();
     }
-  }
 
-export const serviceMethodHandler = (
-  service: any, methodName: string, getArgs: (opts: ServiceParams) => any[], headerOverride?: string
-) => serviceMiddleware(async (req, res, options) => {
-  const methodOverride = typeof headerOverride === 'string' && (req.headers[headerOverride] as string);
-  const method = methodOverride ? methodOverride : methodName
-  const { methods } = getServiceOptions(service);
+    req.lookup = lookup;
 
-  if (!methods.includes(method) || defaultServiceMethods.includes(methodOverride)) {
-    res.status(statusCodes.methodNotAllowed);
+    const options = getServiceOptions(lookup.service);
+    const middleware = options.express!.composed!;
 
-    throw new MethodNotAllowed(`Method \`${method}\` is not supported by this endpoint.`);
+    return middleware(req, res, next);
+  });
+};
+
+export const formatter: RequestHandler = (_req, res, next) => {
+  if (res.data === undefined) {
+    return next();
   }
 
-  const args = getArgs(options);
-  const context = createContext(service, method);
+  res.format({
+    'application/json' () {
+      res.json(res.data);
+    }
+  });
+};
 
-  res.hook = context as any;
+export type RestOptions = {
+  formatter?: RequestHandler;
+  authentication?: AuthenticationSettings;
+};
+
+export const rest = (options?: RestOptions | RequestHandler) => {
+  options = typeof options === 'function' ? { formatter: options } : options || {};
 
-  return service[method](...args, context);
-});
+  const formatterMiddleware = options.formatter || formatter;
+  const authenticationOptions = options.authentication;
 
-export function rest (handler: RequestHandler = formatter) {
-  return function (this: any, app: any) {
+  return (app: Application) => {
     if (typeof app.route !== 'function') {
       throw new Error('@feathersjs/express/rest needs an Express compatible app.');
     }
 
-    app.use(feathersParams);
-    app.use(parseAuthentication());
-
-    // Register the REST provider
-    app.mixins.push(function (service: any, path: string, options: any) {
-      const { middleware: { before = [] } } = options;
-      let { middleware: { after = [] } } = options;
-
-      if (typeof handler === 'function') {
-        after = after.concat(handler);
-      }
-
-      const baseUri = `/${path}`;
-      const find = serviceMethodHandler(service, 'find', ({ params }) => [ params ]);
-      const get = serviceMethodHandler(service, 'get', ({ id, params }) => [ id, params ]);
-      const create = serviceMethodHandler(service, 'create', ({ data, params }) => [ data, params ], METHOD_HEADER);
-      const update = serviceMethodHandler(service, 'update', ({ id, data, params }) => [ id, data, params ]);
-      const patch = serviceMethodHandler(service, 'patch', ({ id, data, params }) => [ id, data, params ]);
-      const remove = serviceMethodHandler(service, 'remove', ({ id, params }) => [ id, params ]);
-
-      debug(`Adding REST provider for service \`${path}\` at base route \`${baseUri}\``);
-
-      const idRoute = '/:__feathersId';
-      const serviceRouter = Router({ mergeParams: true })
-        .get('/', find)
-        .post('/', create)
-        .get(idRoute, get)
-        .put('/', update)
-        .put(idRoute, update)
-        .patch('/', patch)
-        .patch(idRoute, patch)
-        .delete('/', remove)
-        .delete(idRoute, remove);
-
-      app.use(baseUri, ...before, serviceRouter, ...after);
+    app.use(parseAuthentication(authenticationOptions));
+    app.use(servicesMiddleware());
+
+    app.mixins.push((_service, _path, options) => {
+      const { express: { before = [], after = [] } = {} } = options;
+
+      const middlewares = [].concat(before, serviceMiddleware(), after, formatterMiddleware);
+      const middleware = Router().use(middlewares);
+
+      options.express ||= {};
+      options.express.composed = middleware;
     });
   };
 }