@feathersjs/express 5.0.0-pre.9 → 5.0.1

package/src/handlers.ts

@@ -1,130 +1,132 @@
-import path from 'path';
-import { NotFound, GeneralError } from '@feathersjs/errors';
-import { Request, Response, NextFunction, ErrorRequestHandler, RequestHandler } from 'express';
+import path from 'path'
+import { NotFound, GeneralError } from '@feathersjs/errors'
+import { Request, Response, NextFunction, ErrorRequestHandler, RequestHandler } from 'express'
 
 const defaults = {
   public: path.resolve(__dirname, '..', 'public'),
   logger: console
-};
-const defaultHtmlError = path.resolve(defaults.public, 'default.html');
+}
+const defaultHtmlError = path.resolve(defaults.public, 'default.html')
 
-export function notFound ({ verbose = false } = {}): RequestHandler {
+export function notFound({ verbose = false } = {}): RequestHandler {
   return function (req: Request, _res: Response, next: NextFunction) {
-    const url = `${req.url}`;
-    const message = `Page not found${verbose ? ': ' + url : ''}`;
+    const url = `${req.url}`
+    const message = `Page not found${verbose ? ': ' + url : ''}`
 
-    next(new NotFound(message, { url }));
-  };
+    next(new NotFound(message, { url }))
+  }
 }
 
 export type ErrorHandlerOptions = {
-  public?: string,
-  logger?: boolean|{ error?: (msg: any) => void, info?: (msg: any) => void },
-  html?: any,
+  public?: string
+  logger?: boolean | { error?: (msg: any) => void; info?: (msg: any) => void }
+  html?: any
   json?: any
-};
+}
 
-export function errorHandler (_options: ErrorHandlerOptions = {}): ErrorRequestHandler {
-  const options = Object.assign({}, defaults, _options);
+export function errorHandler(_options: ErrorHandlerOptions = {}): ErrorRequestHandler {
+  const options = Object.assign({}, defaults, _options)
 
   if (typeof options.html === 'undefined') {
     options.html = {
       401: path.resolve(options.public, '401.html'),
       404: path.resolve(options.public, '404.html'),
       default: defaultHtmlError
-    };
+    }
   }
 
   if (typeof options.json === 'undefined') {
-    options.json = {};
+    options.json = {}
   }
 
   return function (error: any, req: Request, res: Response, next: NextFunction) {
     // Set the error code for HTTP processing semantics
-    error.code = !isNaN(parseInt(error.code, 10)) ? parseInt(error.code, 10) : 500;
+    error.code = !isNaN(parseInt(error.code, 10)) ? parseInt(error.code, 10) : 500
 
     // Log the error if it didn't come from a service method call
     if (options.logger && typeof options.logger.error === 'function' && !res.hook) {
       if (error.code >= 500) {
-        options.logger.error(error);
+        options.logger.error(error)
       } else {
-        options.logger.info(error);
+        options.logger.info(error)
       }
     }
 
     if (error.type !== 'FeathersError') {
-      const oldError = error;
+      const oldError = error
 
-      error = oldError.errors ? new GeneralError(oldError.message, {
-        errors: oldError.errors
-      }) : new GeneralError(oldError.message);
+      error = oldError.errors
+        ? new GeneralError(oldError.message, {
+            errors: oldError.errors
+          })
+        : new GeneralError(oldError.message)
 
       if (oldError.stack) {
-        error.stack = oldError.stack;
+        error.stack = oldError.stack
       }
     }
 
-    const formatter: { [key: string]: any } = {};
+    const formatter: { [key: string]: any } = {}
 
     // If the developer passed a custom function for ALL html errors
     if (typeof options.html === 'function') {
-      formatter['text/html'] = options.html;
+      formatter['text/html'] = options.html
     } else {
-      let file = options.html[error.code];
+      let file = options.html[error.code]
       if (!file) {
-        file = options.html.default || defaultHtmlError;
+        file = options.html.default || defaultHtmlError
       }
       // If the developer passed a custom function for individual html errors
       if (typeof file === 'function') {
-        formatter['text/html'] = file;
+        formatter['text/html'] = file
       } else {
         formatter['text/html'] = function () {
-          res.set('Content-Type', 'text/html');
-          res.sendFile(file);
-        };
+          res.set('Content-Type', 'text/html')
+          res.sendFile(file)
+        }
       }
     }
 
     // If the developer passed a custom function for ALL json errors
     if (typeof options.json === 'function') {
-      formatter['application/json'] = options.json;
+      formatter['application/json'] = options.json
     } else {
-      const handler = options.json[error.code] || options.json.default;
+      const handler = options.json[error.code] || options.json.default
       // If the developer passed a custom function for individual json errors
       if (typeof handler === 'function') {
-        formatter['application/json'] = handler;
+        formatter['application/json'] = handler
       } else {
         // Don't show stack trace if it is a 404 error
         if (error.code === 404) {
-          error.stack = null;
+          error.stack = null
         }
 
         formatter['application/json'] = function () {
-          const output = Object.assign({}, error.toJSON());
+          const output = Object.assign({}, error.toJSON())
 
           if (process.env.NODE_ENV === 'production') {
-            delete output.stack;
+            delete output.stack
           }
 
-          res.set('Content-Type', 'application/json');
-          res.json(output);
-        };
+          res.set('Content-Type', 'application/json')
+          res.json(output)
+        }
       }
     }
 
-    res.status(error.code);
+    res.status(error.code)
 
-    const contentType = req.headers['content-type'] || '';
-    const accepts = req.headers.accept || '';
+    const contentType = req.headers['content-type'] || ''
+    const accepts = req.headers.accept || ''
 
     // by default just send back json
     if (contentType.indexOf('json') !== -1 || accepts.indexOf('json') !== -1) {
-      formatter['application/json'](error, req, res, next);
+      formatter['application/json'](error, req, res, next)
     } else if (options.html && (contentType.indexOf('html') !== -1 || accepts.indexOf('html') !== -1)) {
-      formatter['text/html'](error, req, res, next);
+      formatter['text/html'](error, req, res, next)
     } else {
       // TODO (EK): Maybe just return plain text
-      formatter['application/json'](error, req, res, next);
+      formatter['application/json'](error, req, res, next)
     }
-  };
+  }
 }

package/src/index.ts

@@ -1,107 +1,156 @@
-import express, {
-  Express, static as _static, json, raw, text, urlencoded, query
-} from 'express';
-import {
-  Application as FeathersApplication, defaultServiceMethods
-} from '@feathersjs/feathers';
-import { createDebug } from '@feathersjs/commons';
-
-import { Application } from './declarations';
-import { errorHandler, notFound } from './handlers';
-import { parseAuthentication, authenticate } from './authentication';
+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 cors from 'cors'
+import compression from 'compression'
+
+import { rest, RestOptions, formatter } from './rest'
+import { errorHandler, notFound, ErrorHandlerOptions } from './handlers'
+import { Application, ExpressOverrides } from './declarations'
+import { AuthenticationSettings, authenticate, parseAuthentication } from './authentication'
+import { default as original, static as serveStatic, json, raw, text, urlencoded, query } from 'express'
 
 export {
-  _static as static, json, raw, text, urlencoded, query,
-  errorHandler, notFound, express as original,
-  authenticate, parseAuthentication
-};
-
-export * from './rest';
-export * from './declarations';
+  original,
+  serveStatic,
+  serveStatic as static,
+  json,
+  raw,
+  text,
+  urlencoded,
+  query,
+  rest,
+  RestOptions,
+  formatter,
+  errorHandler,
+  notFound,
+  Application,
+  ErrorHandlerOptions,
+  ExpressOverrides,
+  AuthenticationSettings,
+  parseAuthentication,
+  authenticate,
+  cors,
+  compression
+}
 
-const debug = createDebug('@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> {
+export default function feathersExpress<S = any, C = any>(
+  feathersApp?: FeathersApplication<S, C>,
+  expressApp: Express = express()
+): Application<S, C> {
   if (!feathersApp) {
-    return expressApp as any;
+    return expressApp as any
   }
 
   if (typeof feathersApp.setup !== 'function') {
-    throw new Error('@feathersjs/express requires a valid Feathers application instance');
+    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[]) {
-      let service: any;
-      let options = {};
+  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 = {}
 
-      const middleware = rest.reduce(function (middleware, arg) {
+      const middleware = rest.reduce(
+        function (middleware, arg) {
           if (typeof arg === 'function' || Array.isArray(arg)) {
-            middleware[service ? 'after' : 'before'].push(arg);
+            middleware[service ? 'after' : 'before'].push(arg)
           } else if (!service) {
-            service = arg;
-          } else if (arg.methods || arg.events) {
-            options = arg;
+            service = arg
+          } else if (arg.methods || arg.events || arg.express || arg.koa) {
+            options = arg
           } else {
-            throw new Error('Invalid options passed to app.use');
+            throw new Error('Invalid options passed to app.use')
           }
-          return middleware;
-        }, {
+          return middleware
+        },
+        {
           before: [],
           after: []
-        });
+        }
+      )
 
-      const hasMethod = (methods: string[]) => methods.some(name =>
-        (service && typeof service[name] === 'function')
-      );
+      const hasMethod = (methods: string[]) =>
+        methods.some((name) => service && typeof service[name] === 'function')
 
       // 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);
+        debug('Passing app.use call to Express app')
+        return expressUse.call(this, location, ...rest)
       }
 
-      debug('Registering service with middleware', middleware);
+      debug('Registering service with middleware', middleware)
       // Since this is a service, call Feathers `.use`
-      (feathersApp as FeathersApplication).use.call(this, location, service, {
-        ...options,
-        middleware
-      });
+      feathersUse.call(this, location, service, {
+        express: middleware,
+        ...options
+      })
 
-      return this;
+      return this
     },
 
-    async listen (...args: any[]) {
-      const server = listen.call(this, ...args);
+    async listen(...args: any[]) {
+      const server = expressListen.call(this, ...args)
 
-      await this.setup(server);
-      debug('Feathers application listening');
+      this.server = server
+      await this.setup(server)
+      debug('Feathers application listening')
 
-      return server;
+      return server
     }
-  };
+  } 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)
     }
-  });
+  })
+
+  // Assign teardown and setup which will also make sure that hooks are initialized
+  app.setup = feathersApp.setup as any
+  app.teardown = async function teardown(server?: any) {
+    return feathersTeardown.call(this, server).then(
+      () =>
+        new Promise((resolve, reject) => {
+          if (this.server) {
+            this.server.close((e) => (e ? reject(e) : resolve(this)))
+          } else {
+            resolve(this)
+          }
+        })
+    )
+  }
+
+  app.configure(routing() as any)
+  app.use((req, _res, next) => {
+    req.feathers = { ...req.feathers, provider: 'rest' }
+    return next()
+  })
 
-  return Object.assign(expressApp, mixin);
+  return app
 }
 
 if (typeof module !== 'undefined') {
-  module.exports = Object.assign(feathersExpress, module.exports);
+  module.exports = Object.assign(feathersExpress, module.exports)
 }

package/src/rest.ts

@@ -1,120 +1,113 @@
-import { MethodNotAllowed } from '@feathersjs/errors';
-import { HookContext } from '@feathersjs/hooks';
-import { createDebug } from '@feathersjs/commons';
-import { http } from '@feathersjs/transport-commons';
-import { createContext, defaultServiceMethods, getServiceOptions } from '@feathersjs/feathers';
-import { Request, Response, NextFunction, RequestHandler, Router } from 'express';
-
-import { parseAuthentication } from './authentication';
-
-const debug = createDebug('@feathersjs/express/rest');
-
-export type ServiceCallback = (req: Request, res: Response, options: http.ServiceParams) => Promise<HookContext|any>;
-
-export const feathersParams = (req: Request, _res: Response, next: NextFunction) => {
-  req.feathers = {
-    ...req.feathers,
-    provider: 'rest',
-    headers: req.headers
-  };
-  next();
+import { Request, Response, RequestHandler, Router } from 'express'
+import { MethodNotAllowed } from '@feathersjs/errors'
+import { createDebug } from '@feathersjs/commons'
+import { http } from '@feathersjs/transport-commons'
+import { createContext, defaultServiceMethods, getServiceOptions } from '@feathersjs/feathers'
+
+import { AuthenticationSettings, parseAuthentication } from './authentication'
+import { Application } from './declarations'
+
+const debug = createDebug('@feathersjs/express/rest')
+
+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 formatter = (_req: Request, res: Response, next: NextFunction) => {
-  if (res.data === undefined) {
-    return next();
-  }
+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
 
-  res.format({
-    'application/json' () {
-      res.json(res.data);
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const { service, params: { __id: id = null, ...route } = {} } = req.lookup!
+    const method = http.getServiceMethod(httpMethod, id, methodOverride)
+    const { methods } = getServiceOptions(service)
+
+    debug(`Found service for path ${path}, attempting to run '${method}' service method`)
+
+    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
     }
-  });
-}
 
+    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
 
-export const serviceMiddleware = (callback: ServiceCallback) =>
-  async (req: Request, res: Response, next: NextFunction) => {
-    debug(`Running service middleware for '${req.url}'`);
+    const context = await (service as any)[method](...args, contextBase)
+    res.hook = context
 
-    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 });
-      const result = http.getData(context);
+    const response = http.getResponse(context)
+    res.statusCode = response.status
+    res.set(response.headers)
+    res.data = response.body
 
-      res.data = result;
-      res.status(http.getStatusCode(context, result));
+    return next()
+  })
+}
+
+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: http.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(http.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)
+    }
+  })
+}
+
+export type RestOptions = {
+  formatter?: RequestHandler
+  authentication?: AuthenticationSettings
+}
 
-  res.hook = context as any;
+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.');
+      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', http.argumentsFor.find);
-      const get = serviceMethodHandler(service, 'get', http.argumentsFor.get);
-      const create = serviceMethodHandler(service, 'create', http.argumentsFor.create, http.METHOD_HEADER);
-      const update = serviceMethodHandler(service, 'update', http.argumentsFor.update);
-      const patch = serviceMethodHandler(service, 'patch', http.argumentsFor.patch);
-      const remove = serviceMethodHandler(service, 'remove', http.argumentsFor.remove);
-
-      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
+    })
+  }
 }