@loopback/rest 6.0.0 → 7.0.1

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

@@ -3,14 +3,23 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {bind, Context, inject, Provider} from '@loopback/core';
+import {
+  BindingScope,
+  Context,
+  inject,
+  injectable,
+  Provider,
+} from '@loopback/core';
 import {asMiddleware, Middleware} from '@loopback/express';
+import debugFactory from 'debug';
 import {HttpHandler} from '../http-handler';
 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(
     @inject(RestBindings.Http.CONTEXT) protected context: Context,
@@ -23,26 +32,33 @@ 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(
+@injectable(
   asMiddleware({
     group: RestMiddlewareGroups.FIND_ROUTE,
     chain: RestTags.REST_MIDDLEWARE_CHAIN,
   }),
+  {scope: BindingScope.SINGLETON},
 )
 export class FindRouteMiddlewareProvider implements Provider<Middleware> {
-  constructor(
-    @inject(RestBindings.SequenceActions.FIND_ROUTE)
-    protected findRoute: FindRoute,
-  ) {}
-
   value(): Middleware {
     return async (ctx, next) => {
-      const route = this.findRoute(ctx.request);
+      const request = ctx.request;
+      debug('Finding route for %s %s', request.method, request.originalUrl);
+      const handler = await ctx.get(RestBindings.HANDLER);
+      const route = handler.findRoute(request);
+      debug(
+        'Route found for %s %s',
+        request.method,
+        request.originalUrl,
+        route,
+      );
+      route.updateBindings(ctx);
       ctx.bind(RestBindings.Operation.ROUTE).to(route);
       return next();
     };

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

@@ -3,13 +3,22 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {bind, Context, inject, Provider} from '@loopback/core';
+import {
+  BindingScope,
+  Context,
+  inject,
+  injectable,
+  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) {}
 
@@ -22,28 +31,37 @@ export class InvokeMethodProvider implements Provider<InvokeMethod> {
   }
 }
 
-@bind(
+@injectable(
   asMiddleware({
     group: RestMiddlewareGroups.INVOKE_METHOD,
     upstreamGroups: RestMiddlewareGroups.PARSE_PARAMS,
     chain: RestTags.REST_MIDDLEWARE_CHAIN,
   }),
+  {scope: BindingScope.SINGLETON},
 )
 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,
       );
-      const retVal = await this.invokeMethod(route, params);
-      ctx.bind(RestBindings.Operation.RETURN_VALUE).to(retVal);
-      return retVal;
+      if (debug.enabled) {
+        debug('Invoking method %s with', route.describe(), params);
+      }
+      try {
+        const retVal = await route.invokeHandler(ctx, 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/log-error.provider.ts

@@ -3,9 +3,10 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Provider} from '@loopback/core';
+import {BindingScope, injectable, Provider} from '@loopback/core';
 import {LogError, Request} from '../types';
 
+@injectable({scope: BindingScope.SINGLETON})
 export class LogErrorProvider implements Provider<LogError> {
   value(): LogError {
     return (err, statusCode, req) => this.action(err, statusCode, req);

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

@@ -3,8 +3,9 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {bind, inject, Provider} from '@loopback/core';
+import {BindingScope, inject, injectable, Provider} from '@loopback/core';
 import {asMiddleware, Middleware} from '@loopback/express';
+import debugFactory from 'debug';
 import {RequestBodyParser} from '../body-parsers';
 import {RestBindings, RestTags} from '../keys';
 import {parseOperationArgs} from '../parser';
@@ -12,6 +13,9 @@ import {ResolvedRoute} from '../router';
 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.
  *
@@ -39,24 +43,40 @@ export class ParseParamsProvider implements Provider<ParseParams> {
   }
 }
 
-@bind(
+@injectable(
   asMiddleware({
     group: RestMiddlewareGroups.PARSE_PARAMS,
     upstreamGroups: RestMiddlewareGroups.FIND_ROUTE,
     chain: RestTags.REST_MIDDLEWARE_CHAIN,
   }),
+  {scope: BindingScope.SINGLETON},
 )
 export class ParseParamsMiddlewareProvider implements Provider<Middleware> {
-  constructor(
-    @inject(RestBindings.SequenceActions.PARSE_PARAMS)
-    protected parseParams: ParseParams,
-  ) {}
-
   value(): Middleware {
     return async (ctx, next) => {
+      const requestBodyParser = await ctx.get(RestBindings.REQUEST_BODY_PARSER);
+      const validationOptions: ValidationOptions =
+        (await ctx.get(
+          RestBindings.REQUEST_BODY_PARSER_OPTIONS.deepProperty('validation'),
+          {optional: true},
+        )) ?? DEFAULT_AJV_VALIDATION_OPTIONS;
+      const ajvFactory = await ctx.get(RestBindings.AJV_FACTORY, {
+        optional: true,
+      });
+
       const route: ResolvedRoute = await ctx.get(RestBindings.Operation.ROUTE);
-      const params = await this.parseParams(ctx.request, route);
+      debug('Parsing parameters for %s %s', route.verb, route.path);
+      const params = await parseOperationArgs(
+        ctx.request,
+        route,
+        requestBodyParser,
+        {
+          ajvFactory: ajvFactory,
+          ...validationOptions,
+        },
+      );
       ctx.bind(RestBindings.Operation.PARAMS).to(params);
+      debug('Parameters', params);
       return next();
     };
   }

package/src/providers/reject.provider.ts

@@ -3,11 +3,11 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {LogError, Reject, HandlerContext} from '../types';
-import {inject, Provider} from '@loopback/core';
+import {BindingScope, inject, injectable, Provider} from '@loopback/core';
 import {HttpError} from 'http-errors';
+import {ErrorWriterOptions, writeErrorToResponse} from 'strong-error-handler';
 import {RestBindings} from '../keys';
-import {writeErrorToResponse, ErrorWriterOptions} from 'strong-error-handler';
+import {HandlerContext, LogError, Reject} from '../types';
 
 // TODO(bajtos) Make this mapping configurable at RestServer level,
 // allow apps and extensions to contribute additional mappings.
@@ -15,6 +15,7 @@ const codeToStatusCodeMap: {[key: string]: number} = {
   ENTITY_NOT_FOUND: 404,
 };
 
+@injectable({scope: BindingScope.SINGLETON})
 export class RejectProvider implements Provider<Reject> {
   constructor(
     @inject(RestBindings.SequenceActions.LOG_ERROR)

package/src/providers/send.provider.ts

@@ -3,11 +3,11 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {bind, inject, Provider} from '@loopback/core';
+import {BindingScope, injectable, 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 {Send} from '../types';
 import {writeResultToResponse} from '../writer';
 /**
  * Provides the function that populates the response object with
@@ -16,13 +16,14 @@ import {writeResultToResponse} from '../writer';
  * @returns The handler function that will populate the
  * response with operation results.
  */
+@injectable({scope: BindingScope.SINGLETON})
 export class SendProvider implements Provider<Send> {
   value() {
     return writeResultToResponse;
   }
 }
 
-@bind(
+@injectable(
   asMiddleware({
     group: RestMiddlewareGroups.SEND_RESPONSE,
     downstreamGroups: [
@@ -31,17 +32,13 @@ export class SendProvider implements Provider<Send> {
     ],
     chain: RestTags.REST_MIDDLEWARE_CHAIN,
   }),
+  {scope: BindingScope.SINGLETON},
 )
 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) => {
+      const send = await ctx.get(RestBindings.SequenceActions.SEND);
+      const reject = await ctx.get(RestBindings.SequenceActions.REJECT);
       try {
         /**
          * Invoke downstream middleware to produce the result
@@ -50,12 +47,12 @@ export class SendResponseMiddlewareProvider implements Provider<Middleware> {
         /**
          * Write the result to HTTP response
          */
-        this.send(ctx.response, result);
+        send(ctx.response, result);
       } catch (err) {
         /**
          * Write the error to HTTP response
          */
-        this.reject(ctx, err);
+        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) {
@@ -368,7 +368,7 @@ export class RestApplication extends Application implements HttpServerLike {
    * @returns Binding for the api spec
    */
   api(spec: OpenApiSpec): Binding {
-    return this.bind(RestBindings.API_SPEC).to(spec);
+    return this.restServer.bind(RestBindings.API_SPEC).to(spec);
   }
 
   /**

package/src/rest.component.ts

@@ -43,7 +43,6 @@ import {
   RestServer,
   RestServerConfig,
 } from './rest.server';
-import {MiddlewareSequence} 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';
@@ -120,7 +119,6 @@ export class RestComponent implements Component {
     ).tag({[CoreTags.EXTENSION_POINT]: RestTags.REST_MIDDLEWARE_CHAIN});
     app.add(invokeMiddlewareServiceBinding);
 
-    app.bind(RestBindings.SEQUENCE).toClass(MiddlewareSequence);
     const apiSpec = createEmptyApiSpec();
     // Merge the OpenAPI `servers` spec from the config into the empty one
     if (config?.openApiSpec?.servers) {

package/src/rest.server.ts

@@ -64,6 +64,7 @@ import {
 import {assignRouterSpec} from './router/router-spec';
 import {
   DefaultSequence,
+  MiddlewareSequence,
   RestMiddlewareGroups,
   SequenceFunction,
   SequenceHandler,
@@ -110,7 +111,8 @@ const SequenceActions = RestBindings.SequenceActions;
  * const server = await app.get('servers.foo');
  * ```
  */
-export class RestServer extends BaseMiddlewareRegistry
+export class RestServer
+  extends BaseMiddlewareRegistry
   implements Server, HttpServerLike {
   /**
    * Handle incoming HTTP(S) request by invoking the corresponding
@@ -169,6 +171,10 @@ export class RestServer extends BaseMiddlewareRegistry
     return this._httpServer ? this._httpServer.listening : false;
   }
 
+  get httpServer(): HttpServer | undefined {
+    return this._httpServer;
+  }
+
   /**
    * The base url for the server, including the basePath if set. For example,
    * the value will be 'http://localhost:3000/api' if `basePath` is set to
@@ -222,6 +228,8 @@ export class RestServer extends BaseMiddlewareRegistry
 
     if (config.sequence) {
       this.sequence(config.sequence);
+    } else {
+      this.sequence(MiddlewareSequence);
     }
 
     if (config.router) {
@@ -889,10 +897,14 @@ export class RestServer extends BaseMiddlewareRegistry
    * }
    * ```
    *
-   * @param value - The sequence to invoke for each incoming request.
+   * @param sequenceClass - The sequence class to invoke for each incoming request.
    */
-  public sequence(value: Constructor<SequenceHandler>) {
-    this.bind(RestBindings.SEQUENCE).toClass(value);
+  public sequence(sequenceClass: Constructor<SequenceHandler>) {
+    const sequenceBinding = createBindingFromClass(sequenceClass, {
+      key: RestBindings.SEQUENCE,
+    });
+    this.add(sequenceBinding);
+    return sequenceBinding;
   }
 
   /**
@@ -971,10 +983,7 @@ export class RestServer extends BaseMiddlewareRegistry
       return;
     }
 
-    const serverOptions = {};
-    if (protocol === 'https') Object.assign(serverOptions, httpsOptions);
-    Object.assign(serverOptions, {port, host, protocol, path});
-
+    const serverOptions = {...httpsOptions, port, host, protocol, path};
     this._httpServer = new HttpServer(this.requestHandler, serverOptions);
 
     await this._httpServer.start();

package/src/router/base-route.ts

@@ -36,11 +36,11 @@ export abstract class BaseRoute implements RouteEntry {
   ): Promise<OperationRetval>;
 
   describe(): string {
-    return `"${this.verb} ${this.path}"`;
+    return `${this.verb} ${this.path}`;
   }
 
   toString() {
-    return `${this.constructor.name} - ${this.verb} ${this.path}`;
+    return `${this.constructor.name} - ${this.describe()}`;
   }
 }
 
@@ -48,6 +48,6 @@ export class RouteSource implements InvocationSource<RouteEntry> {
   type = 'route';
   constructor(readonly value: RouteEntry) {}
   toString() {
-    return `${this.value.verb} ${this.value.path}`;
+    return this.value.toString();
   }
 }

package/src/router/controller-route.ts

@@ -101,7 +101,7 @@ export class ControllerRoute<T> extends BaseRoute {
   }
 
   describe(): string {
-    return `${this._controllerName}.${this._methodName}`;
+    return `${super.describe()} => ${this._controllerName}.${this._methodName}`;
   }
 
   updateBindings(requestContext: Context) {

package/src/router/handler-route.ts

@@ -20,7 +20,9 @@ export class Route extends BaseRoute {
   }
 
   describe(): string {
-    return this._handler.name || super.describe();
+    return `${super.describe()} => ${
+      this._handler.name || this._handler.toString()
+    }`;
   }
 
   updateBindings(requestContext: Context) {

package/src/router/redirect-route.ts

@@ -42,7 +42,7 @@ export class RedirectRoute implements RouteEntry, ResolvedRoute {
   }
 
   describe(): string {
-    return `RedirectRoute from "${this.sourcePath}" to "${this.targetLocation}"`;
+    return `Redirect: "${this.sourcePath}" => "${this.targetLocation}"`;
   }
 
   /**

package/src/sequence.ts

@@ -3,11 +3,19 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {config, inject, ValueOrPromise} from '@loopback/core';
+import {
+  BindingScope,
+  config,
+  Context,
+  inject,
+  injectable,
+  ValueOrPromise,
+} from '@loopback/core';
 import {
   InvokeMiddleware,
   InvokeMiddlewareOptions,
   MiddlewareGroups,
+  MiddlewareView,
 } from '@loopback/express';
 import debugFactory from 'debug';
 import {RestBindings, RestTags} from './keys';
@@ -177,7 +185,10 @@ export namespace RestMiddlewareGroups {
 /**
  * A sequence implementation using middleware chains
  */
+@injectable({scope: BindingScope.SINGLETON})
 export class MiddlewareSequence implements SequenceHandler {
+  private middlewareView: MiddlewareView;
+
   static defaultOptions: InvokeMiddlewareOptions = {
     chain: RestTags.REST_MIDDLEWARE_CHAIN,
     orderedGroups: [
@@ -199,6 +210,26 @@ export class MiddlewareSequence implements SequenceHandler {
 
       RestMiddlewareGroups.INVOKE_METHOD,
     ],
+
+    /**
+     * Reports an error if there are middleware groups are unreachable as they
+     * are ordered after the `invokeMethod` group.
+     */
+    validate: groups => {
+      const index = groups.indexOf(RestMiddlewareGroups.INVOKE_METHOD);
+      if (index !== -1) {
+        const unreachableGroups = groups.slice(index + 1);
+        if (unreachableGroups.length > 0) {
+          throw new Error(
+            `Middleware groups "${unreachableGroups.join(
+              ',',
+            )}" are not invoked as they are ordered after "${
+              RestMiddlewareGroups.INVOKE_METHOD
+            }"`,
+          );
+        }
+      }
+    },
   };
 
   /**
@@ -208,11 +239,17 @@ export class MiddlewareSequence implements SequenceHandler {
    * To be injected via RestBindings.INVOKE_MIDDLEWARE_SERVICE.
    */
   constructor(
+    @inject.context()
+    context: Context,
+
     @inject(RestBindings.INVOKE_MIDDLEWARE_SERVICE)
     readonly invokeMiddleware: InvokeMiddleware,
     @config()
     readonly options: InvokeMiddlewareOptions = MiddlewareSequence.defaultOptions,
-  ) {}
+  ) {
+    this.middlewareView = new MiddlewareView(context, options);
+    debug('Discovered middleware', this.middlewareView.middlewareBindingKeys);
+  }
 
   /**
    * Runs the default sequence. Given a handler context (request and response),
@@ -246,6 +283,11 @@ export class MiddlewareSequence implements SequenceHandler {
       this.options.chain,
       this.options.orderedGroups,
     );
-    await this.invokeMiddleware(context, this.options);
+    const options: InvokeMiddlewareOptions = {
+      middlewareList: this.middlewareView.middlewareBindingKeys,
+      validate: MiddlewareSequence.defaultOptions.validate,
+      ...this.options,
+    };
+    await this.invokeMiddleware(context, options);
   }
 }

package/src/spec-enhancers/consolidate.spec-enhancer.ts

@@ -5,10 +5,10 @@
 
 import {
   ApplicationConfig,
-  bind,
   BindingScope,
   CoreBindings,
   inject,
+  injectable,
 } from '@loopback/core';
 import {
   asSpecEnhancer,
@@ -58,7 +58,7 @@ const debug = debugFactory('loopback:openapi:spec-enhancer:consolidate');
  * When comparing schemas to avoid naming collisions, the description field
  * is ignored.
  */
-@bind(asSpecEnhancer, {scope: BindingScope.SINGLETON})
+@injectable(asSpecEnhancer, {scope: BindingScope.SINGLETON})
 export class ConsolidationEnhancer implements OASEnhancer {
   name = 'consolidate';
   disabled: boolean;

package/src/spec-enhancers/info.spec-enhancer.ts

@@ -5,16 +5,17 @@
 
 import {
   ApplicationMetadata,
-  bind,
   BindingScope,
   CoreBindings,
   inject,
+  injectable,
   JSONObject,
   JSONValue,
 } from '@loopback/core';
 import {
   asSpecEnhancer,
   ContactObject,
+  DEFAULT_OPENAPI_SPEC_INFO,
   mergeOpenAPISpec,
   OASEnhancer,
   OpenApiSpec,
@@ -27,7 +28,7 @@ const debug = debugFactory('loopback:openapi:spec-enhancer:info');
  * An OpenAPI spec enhancer to populate `info` with application metadata
  * (package.json).
  */
-@bind(asSpecEnhancer, {scope: BindingScope.SINGLETON})
+@injectable(asSpecEnhancer, {scope: BindingScope.SINGLETON})
 export class InfoSpecEnhancer implements OASEnhancer {
   name = 'info';
 
@@ -44,12 +45,20 @@ export class InfoSpecEnhancer implements OASEnhancer {
     const contact: ContactObject = InfoSpecEnhancer.parseAuthor(
       this.pkg.author,
     );
+    // Only override `info` if the `spec.info` is not customized
+    const overrideInfo =
+      spec.info.title === DEFAULT_OPENAPI_SPEC_INFO.title &&
+      spec.info.version === DEFAULT_OPENAPI_SPEC_INFO.version;
     const patchSpec = {
       info: {
-        title: this.pkg.name,
-        description: this.pkg.description,
-        version: this.pkg.version,
-        contact,
+        title: overrideInfo ? this.pkg.name : spec.info.title ?? this.pkg.name,
+        description: overrideInfo
+          ? this.pkg.description
+          : spec.info.description ?? this.pkg.description,
+        version: overrideInfo
+          ? this.pkg.version
+          : spec.info.version ?? this.pkg.version,
+        contact: overrideInfo ? contact : spec.info.contact ?? contact,
       },
     };
     debug('Enhancing OpenAPI spec with %j', patchSpec);

package/src/types.ts

@@ -117,6 +117,11 @@ export interface ValueValidationOptions extends ValidationOptions {
    * 'query', 'cookie', etc...
    */
   source?: string;
+
+  /**
+   * Parameter name, as provided in `ParameterObject#name` property.
+   */
+  name?: string;
 }
 
 /**