@loopback/rest 5.2.0 → 6.2.0

package/src/coercion/coerce-parameter.ts

@@ -11,12 +11,13 @@ import {
 } from '@loopback/openapi-v3';
 import debugModule from 'debug';
 import {
-  RequestBodyValidationOptions,
   RestHttpErrors,
   validateValueAgainstSchema,
+  ValidationOptions,
   ValueValidationOptions,
 } from '../';
 import {parseJson} from '../parse-json';
+import {DEFAULT_AJV_VALIDATION_OPTIONS} from '../validation/ajv-factory.provider';
 import {
   DateCoercionOptions,
   getOAIPrimitiveType,
@@ -167,7 +168,7 @@ function coerceBoolean(data: string | object, spec: ParameterObject) {
 async function coerceObject(
   input: string | object,
   spec: ParameterObject,
-  options?: RequestBodyValidationOptions,
+  options: ValidationOptions = DEFAULT_AJV_VALIDATION_OPTIONS,
 ) {
   const data = parseJsonIfNeeded(input, spec);
 
@@ -186,7 +187,7 @@ async function coerceObject(
       data,
       schema,
       {},
-      {...options, coerceTypes: true, source: 'parameter'},
+      {...options, coerceTypes: true, source: 'parameter', name: spec.name},
     );
   }
 

package/src/keys.ts

@@ -4,7 +4,7 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {BindingKey, Context, CoreBindings} from '@loopback/core';
-import {InvokeMiddleware} from '@loopback/express';
+import {DEFAULT_MIDDLEWARE_CHAIN, InvokeMiddleware} from '@loopback/express';
 import {HttpProtocol} from '@loopback/http-server';
 import {OpenApiSpec, OperationObject} from '@loopback/openapi-v3';
 import https from 'https';
@@ -12,13 +12,15 @@ import {ErrorWriterOptions} from 'strong-error-handler';
 import {BodyParser, RequestBodyParser} from './body-parsers';
 import {HttpHandler} from './http-handler';
 import {RestServer, RestServerConfig} from './rest.server';
-import {RestRouter, RestRouterOptions} from './router';
+import {ResolvedRoute, RestRouter, RestRouterOptions} from './router';
 import {SequenceHandler} from './sequence';
 import {
   AjvFactory,
   FindRoute,
   InvokeMethod,
   LogError,
+  OperationArgs,
+  OperationRetval,
   ParseParams,
   Reject,
   Request,
@@ -179,12 +181,20 @@ export namespace RestBindings {
    */
   export const SEQUENCE = BindingKey.create<SequenceHandler>('rest.sequence');
 
+  /**
+   * Binding key for setting and injecting a `invokeMiddleware` function for
+   * middleware based sequence
+   */
+  export const INVOKE_MIDDLEWARE_SERVICE = BindingKey.create<InvokeMiddleware>(
+    'rest.invokeMiddleware',
+  );
+
   /**
    * Bindings for potential actions that could be used in a sequence
    */
   export namespace SequenceActions {
     /**
-     * Binding key for setting and injecting a route finding function
+     * Binding key for setting and injecting `invokeMiddleware` function
      */
     export const INVOKE_MIDDLEWARE = BindingKey.create<InvokeMiddleware>(
       'rest.sequence.actions.invokeMiddleware',
@@ -225,6 +235,20 @@ export namespace RestBindings {
     );
   }
 
+  export namespace Operation {
+    export const ROUTE = BindingKey.create<ResolvedRoute>(
+      'rest.operation.route',
+    );
+
+    export const PARAMS = BindingKey.create<OperationArgs>(
+      'rest.operation.params',
+    );
+
+    export const RETURN_VALUE = BindingKey.create<OperationRetval>(
+      'rest.operation.returnValue',
+    );
+  }
+
   /**
    * Request-specific bindings
    */
@@ -285,4 +309,11 @@ export namespace RestTags {
 
   export const AJV_KEYWORD = 'ajvKeyword';
   export const AJV_FORMAT = 'ajvFormat';
+
+  export const REST_MIDDLEWARE_CHAIN = DEFAULT_MIDDLEWARE_CHAIN;
+
+  /**
+   * Legacy middleware chain for action-based REST sequence
+   */
+  export const ACTION_MIDDLEWARE_CHAIN = 'middlewareChain.rest.actions';
 }

package/src/parser.ts

@@ -19,8 +19,9 @@ import {
   OperationArgs,
   PathParameterValues,
   Request,
-  RequestBodyValidationOptions,
+  ValidationOptions,
 } from './types';
+import {DEFAULT_AJV_VALIDATION_OPTIONS} from './validation/ajv-factory.provider';
 import {validateRequestBody} from './validation/request-body.validator';
 const debug = debugFactory('loopback:rest:parser');
 
@@ -35,7 +36,7 @@ export async function parseOperationArgs(
   request: Request,
   route: ResolvedRoute,
   requestBodyParser: RequestBodyParser = new RequestBodyParser(),
-  options: RequestBodyValidationOptions = {},
+  options: ValidationOptions = DEFAULT_AJV_VALIDATION_OPTIONS,
 ): Promise<OperationArgs> {
   debug('Parsing operation arguments for route %s', route.describe());
   const operationSpec = route.spec;
@@ -60,7 +61,7 @@ async function buildOperationArguments(
   pathParams: PathParameterValues,
   body: RequestBody,
   globalSchemas: SchemasObject,
-  options: RequestBodyValidationOptions = {},
+  options: ValidationOptions = DEFAULT_AJV_VALIDATION_OPTIONS,
 ): Promise<OperationArgs> {
   let requestBodyIndex = -1;
   if (operationSpec.requestBody) {

package/src/providers/find-route.provider.ts

@@ -3,11 +3,16 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Context, inject, Provider} from '@loopback/core';
-import {FindRoute, Request} from '../types';
+import {bind, Context, inject, Provider} from '@loopback/core';
+import {asMiddleware, Middleware} from '@loopback/express';
+import debugFactory from 'debug';
 import {HttpHandler} from '../http-handler';
-import {RestBindings} from '../keys';
+import {RestBindings, RestTags} from '../keys';
 import {ResolvedRoute} from '../router';
+import {RestMiddlewareGroups} from '../sequence';
+import {FindRoute, Request} from '../types';
+
+const debug = debugFactory('loopback:rest:find-route');
 
 export class FindRouteProvider implements Provider<FindRoute> {
   constructor(
@@ -21,7 +26,35 @@ export class FindRouteProvider implements Provider<FindRoute> {
 
   action(request: Request): ResolvedRoute {
     const found = this.handler.findRoute(request);
+    debug('Route found for %s %s', request.method, request.originalUrl, found);
     found.updateBindings(this.context);
     return found;
   }
 }
+
+@bind(
+  asMiddleware({
+    group: RestMiddlewareGroups.FIND_ROUTE,
+    chain: RestTags.REST_MIDDLEWARE_CHAIN,
+  }),
+)
+export class FindRouteMiddlewareProvider implements Provider<Middleware> {
+  constructor(
+    @inject(RestBindings.SequenceActions.FIND_ROUTE)
+    protected findRoute: FindRoute,
+  ) {}
+
+  value(): Middleware {
+    return async (ctx, next) => {
+      debug(
+        'Finding route for %s %s',
+        ctx.request.method,
+        ctx.request.originalUrl,
+      );
+      const route = this.findRoute(ctx.request);
+      debug('Route found', route);
+      ctx.bind(RestBindings.Operation.ROUTE).to(route);
+      return next();
+    };
+  }
+}

package/src/providers/invoke-method.provider.ts

@@ -3,10 +3,15 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Context, inject, Provider} from '@loopback/core';
-import {InvokeMethod, OperationArgs, OperationRetval} from '../types';
-import {RestBindings} from '../keys';
+import {bind, Context, inject, Provider} from '@loopback/core';
+import {asMiddleware, Middleware} from '@loopback/express';
+import debugFactory from 'debug';
+import {RestBindings, RestTags} from '../keys';
 import {RouteEntry} from '../router';
+import {RestMiddlewareGroups} from '../sequence';
+import {InvokeMethod, OperationArgs, OperationRetval} from '../types';
+
+const debug = debugFactory('loopback:rest:invoke-method');
 
 export class InvokeMethodProvider implements Provider<InvokeMethod> {
   constructor(@inject(RestBindings.Http.CONTEXT) protected context: Context) {}
@@ -19,3 +24,42 @@ export class InvokeMethodProvider implements Provider<InvokeMethod> {
     return route.invokeHandler(this.context, args);
   }
 }
+
+@bind(
+  asMiddleware({
+    group: RestMiddlewareGroups.INVOKE_METHOD,
+    upstreamGroups: RestMiddlewareGroups.PARSE_PARAMS,
+    chain: RestTags.REST_MIDDLEWARE_CHAIN,
+  }),
+)
+export class InvokeMethodMiddlewareProvider implements Provider<Middleware> {
+  constructor(
+    @inject(RestBindings.SequenceActions.INVOKE_METHOD)
+    protected invokeMethod: InvokeMethod,
+  ) {}
+
+  value(): Middleware {
+    return async (ctx, next) => {
+      const route: RouteEntry = await ctx.get(RestBindings.Operation.ROUTE);
+      const params: OperationArgs = await ctx.get(
+        RestBindings.Operation.PARAMS,
+      );
+      if (debug.enabled) {
+        debug('Invoking method %s with', route.describe(), params);
+      }
+      try {
+        const retVal = await this.invokeMethod(route, params);
+        ctx.bind(RestBindings.Operation.RETURN_VALUE).to(retVal);
+        if (debug.enabled) {
+          debug('Return value from %s', route.describe(), retVal);
+        }
+        return retVal;
+      } catch (err) {
+        if (debug.enabled) {
+          debug('Error thrown from %s', route.describe(), err);
+        }
+        throw err;
+      }
+    };
+  }
+}

package/src/providers/parse-params.provider.ts

@@ -3,17 +3,19 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {inject, Provider} from '@loopback/core';
+import {bind, inject, Provider} from '@loopback/core';
+import {asMiddleware, Middleware} from '@loopback/express';
+import debugFactory from 'debug';
 import {RequestBodyParser} from '../body-parsers';
-import {RestBindings} from '../keys';
+import {RestBindings, RestTags} from '../keys';
 import {parseOperationArgs} from '../parser';
 import {ResolvedRoute} from '../router';
-import {
-  AjvFactory,
-  ParseParams,
-  Request,
-  RequestBodyValidationOptions,
-} from '../types';
+import {RestMiddlewareGroups} from '../sequence';
+import {AjvFactory, ParseParams, Request, ValidationOptions} from '../types';
+import {DEFAULT_AJV_VALIDATION_OPTIONS} from '../validation/ajv-factory.provider';
+
+const debug = debugFactory('loopback:rest:parse-param');
+
 /**
  * Provides the function for parsing args in requests at runtime.
  *
@@ -27,7 +29,7 @@ export class ParseParamsProvider implements Provider<ParseParams> {
       RestBindings.REQUEST_BODY_PARSER_OPTIONS.deepProperty('validation'),
       {optional: true},
     )
-    private validationOptions: RequestBodyValidationOptions = {},
+    private validationOptions: ValidationOptions = DEFAULT_AJV_VALIDATION_OPTIONS,
     @inject(RestBindings.AJV_FACTORY, {optional: true})
     private ajvFactory?: AjvFactory,
   ) {}
@@ -40,3 +42,28 @@ export class ParseParamsProvider implements Provider<ParseParams> {
       });
   }
 }
+
+@bind(
+  asMiddleware({
+    group: RestMiddlewareGroups.PARSE_PARAMS,
+    upstreamGroups: RestMiddlewareGroups.FIND_ROUTE,
+    chain: RestTags.REST_MIDDLEWARE_CHAIN,
+  }),
+)
+export class ParseParamsMiddlewareProvider implements Provider<Middleware> {
+  constructor(
+    @inject(RestBindings.SequenceActions.PARSE_PARAMS)
+    protected parseParams: ParseParams,
+  ) {}
+
+  value(): Middleware {
+    return async (ctx, next) => {
+      const route: ResolvedRoute = await ctx.get(RestBindings.Operation.ROUTE);
+      debug('Parsing parameters for %s %s', route.verb, route.path);
+      const params = await this.parseParams(ctx.request, route);
+      ctx.bind(RestBindings.Operation.PARAMS).to(params);
+      debug('Parameters', params);
+      return next();
+    };
+  }
+}

package/src/providers/send.provider.ts

@@ -3,7 +3,11 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Provider, BoundValue} from '@loopback/core';
+import {bind, inject, Provider} from '@loopback/core';
+import {asMiddleware, Middleware} from '@loopback/express';
+import {RestBindings, RestTags} from '../keys';
+import {RestMiddlewareGroups} from '../sequence';
+import {Reject, Send} from '../types';
 import {writeResultToResponse} from '../writer';
 /**
  * Provides the function that populates the response object with
@@ -12,8 +16,47 @@ import {writeResultToResponse} from '../writer';
  * @returns The handler function that will populate the
  * response with operation results.
  */
-export class SendProvider implements Provider<BoundValue> {
+export class SendProvider implements Provider<Send> {
   value() {
     return writeResultToResponse;
   }
 }
+
+@bind(
+  asMiddleware({
+    group: RestMiddlewareGroups.SEND_RESPONSE,
+    downstreamGroups: [
+      RestMiddlewareGroups.CORS,
+      RestMiddlewareGroups.INVOKE_METHOD,
+    ],
+    chain: RestTags.REST_MIDDLEWARE_CHAIN,
+  }),
+)
+export class SendResponseMiddlewareProvider implements Provider<Middleware> {
+  constructor(
+    @inject(RestBindings.SequenceActions.SEND)
+    protected send: Send,
+    @inject(RestBindings.SequenceActions.REJECT)
+    protected reject: Reject,
+  ) {}
+
+  value(): Middleware {
+    return async (ctx, next) => {
+      try {
+        /**
+         * Invoke downstream middleware to produce the result
+         */
+        const result = await next();
+        /**
+         * Write the result to HTTP response
+         */
+        this.send(ctx.response, result);
+      } catch (err) {
+        /**
+         * Write the error to HTTP response
+         */
+        this.reject(ctx, err);
+      }
+    };
+  }
+}

package/src/request-context.ts

@@ -17,7 +17,8 @@ import {RestServerResolvedConfig} from './rest.server';
  * A per-request Context combining an IoC container with handler context
  * (request, response, etc.).
  */
-export class RequestContext extends MiddlewareContext
+export class RequestContext
+  extends MiddlewareContext
   implements HandlerContext {
   /**
    * Get the protocol used by the client to make the request.

package/src/rest-http-error.ts

@@ -11,7 +11,7 @@ export namespace RestHttpErrors {
     name: string,
     extraProperties?: Props,
   ): HttpErrors.HttpError & Props {
-    const msg = `Invalid data ${JSON.stringify(data)} for parameter ${name}!`;
+    const msg = `Invalid data ${JSON.stringify(data)} for parameter "${name}".`;
     return Object.assign(
       new HttpErrors.BadRequest(msg),
       {
@@ -51,11 +51,15 @@ export namespace RestHttpErrors {
 
   export const INVALID_REQUEST_BODY_MESSAGE =
     'The request body is invalid. See error object `details` property for more info.';
-  export function invalidRequestBody(): HttpErrors.HttpError {
+
+  export function invalidRequestBody(
+    details: ValidationErrorDetails[],
+  ): HttpErrors.HttpError & {details: ValidationErrorDetails[]} {
     return Object.assign(
       new HttpErrors.UnprocessableEntity(INVALID_REQUEST_BODY_MESSAGE),
       {
         code: 'VALIDATION_FAILED',
+        details,
       },
     );
   }

package/src/rest.application.ts

@@ -102,7 +102,7 @@ export class RestApplication extends Application implements HttpServerLike {
   }
 
   sequence(sequence: Constructor<SequenceHandler>): Binding {
-    return this.bind(RestBindings.SEQUENCE).toClass(sequence);
+    return this.restServer.sequence(sequence);
   }
 
   handler(handlerFn: SequenceFunction) {

package/src/rest.component.ts

@@ -4,15 +4,14 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {
+  Application,
   Binding,
+  Component,
   Constructor,
+  CoreBindings,
+  CoreTags,
   createBindingFromClass,
   inject,
-} from '@loopback/core';
-import {
-  Application,
-  Component,
-  CoreBindings,
   ProviderMap,
   Server,
 } from '@loopback/core';
@@ -26,21 +25,24 @@ import {
   UrlEncodedBodyParser,
 } from './body-parsers';
 import {RawBodyParser} from './body-parsers/body-parser.raw';
-import {RestBindings} from './keys';
+import {RestBindings, RestTags} from './keys';
 import {
+  FindRouteMiddlewareProvider,
   FindRouteProvider,
+  InvokeMethodMiddlewareProvider,
   InvokeMethodProvider,
   LogErrorProvider,
+  ParseParamsMiddlewareProvider,
   ParseParamsProvider,
   RejectProvider,
   SendProvider,
+  SendResponseMiddlewareProvider,
 } from './providers';
 import {
   createBodyParserBinding,
   RestServer,
   RestServerConfig,
 } from './rest.server';
-import {DefaultSequence} from './sequence';
 import {ConsolidationEnhancer} from './spec-enhancers/consolidate.spec-enhancer';
 import {InfoSpecEnhancer} from './spec-enhancers/info.spec-enhancer';
 import {AjvFactoryProvider} from './validation/ajv-factory.provider';
@@ -48,8 +50,6 @@ import {AjvFactoryProvider} from './validation/ajv-factory.provider';
 export class RestComponent implements Component {
   providers: ProviderMap = {
     [RestBindings.SequenceActions.LOG_ERROR.key]: LogErrorProvider,
-    [RestBindings.SequenceActions.INVOKE_MIDDLEWARE
-      .key]: InvokeMiddlewareProvider,
     [RestBindings.SequenceActions.FIND_ROUTE.key]: FindRouteProvider,
     [RestBindings.SequenceActions.INVOKE_METHOD.key]: InvokeMethodProvider,
     [RestBindings.SequenceActions.REJECT.key]: RejectProvider,
@@ -86,6 +86,8 @@ export class RestComponent implements Component {
     ),
     createBindingFromClass(InfoSpecEnhancer),
     createBindingFromClass(ConsolidationEnhancer),
+
+    ...getRestMiddlewareBindings(),
   ];
   servers: {
     [name: string]: Constructor<Server>;
@@ -97,7 +99,26 @@ export class RestComponent implements Component {
     @inject(CoreBindings.APPLICATION_INSTANCE) app: Application,
     @inject(RestBindings.CONFIG) config?: RestComponentConfig,
   ) {
-    app.bind(RestBindings.SEQUENCE).toClass(DefaultSequence);
+    // Register the `InvokeMiddleware` with default to `ACTION_MIDDLEWARE_CHAIN`
+    // to keep backward compatibility with action based sequence
+    const invokeMiddlewareActionBinding = createBindingFromClass(
+      InvokeMiddlewareProvider,
+      {
+        key: RestBindings.SequenceActions.INVOKE_MIDDLEWARE,
+      },
+    ).tag({[CoreTags.EXTENSION_POINT]: RestTags.ACTION_MIDDLEWARE_CHAIN});
+    app.add(invokeMiddlewareActionBinding);
+
+    // Register the `InvokeMiddleware` with default to `DEFAULT_MIDDLEWARE_CHAIN`
+    // for the middleware based sequence
+    const invokeMiddlewareServiceBinding = createBindingFromClass(
+      InvokeMiddlewareProvider,
+      {
+        key: RestBindings.INVOKE_MIDDLEWARE_SERVICE,
+      },
+    ).tag({[CoreTags.EXTENSION_POINT]: RestTags.REST_MIDDLEWARE_CHAIN});
+    app.add(invokeMiddlewareServiceBinding);
+
     const apiSpec = createEmptyApiSpec();
     // Merge the OpenAPI `servers` spec from the config into the empty one
     if (config?.openApiSpec?.servers) {
@@ -107,5 +128,14 @@ export class RestComponent implements Component {
   }
 }
 
+function getRestMiddlewareBindings() {
+  return [
+    SendResponseMiddlewareProvider,
+    FindRouteMiddlewareProvider,
+    ParseParamsMiddlewareProvider,
+    InvokeMethodMiddlewareProvider,
+  ].map(cls => createBindingFromClass(cls));
+}
+
 // TODO(kevin): Extend this interface def to include multiple servers?
 export type RestComponentConfig = RestServerConfig;