@loopback/rest 1.23.0 → 1.26.0

package/src/router/base-route.ts

@@ -3,7 +3,7 @@
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
 
-import {Context} from '@loopback/context';
+import {Context, InvocationSource} from '@loopback/context';
 import {OperationObject} from '@loopback/openapi-v3';
 import {OperationArgs, OperationRetval} from '../types';
 import {RouteEntry} from './route-entry';
@@ -38,4 +38,16 @@ export abstract class BaseRoute implements RouteEntry {
   describe(): string {
     return `"${this.verb} ${this.path}"`;
   }
+
+  toString() {
+    return `${this.constructor.name} - ${this.verb} ${this.path}`;
+  }
+}
+
+export class RouteSource implements InvocationSource<RouteEntry> {
+  type = 'route';
+  constructor(readonly value: RouteEntry) {}
+  toString() {
+    return `${this.value.verb} ${this.value.path}`;
+  }
 }

package/src/router/controller-route.ts

@@ -13,10 +13,10 @@ import {
 } from '@loopback/context';
 import {CoreBindings} from '@loopback/core';
 import {OperationObject} from '@loopback/openapi-v3';
-import * as HttpErrors from 'http-errors';
+import HttpErrors from 'http-errors';
 import {RestBindings} from '../keys';
 import {OperationArgs, OperationRetval} from '../types';
-import {BaseRoute} from './base-route';
+import {BaseRoute, RouteSource} from './base-route';
 
 /*
  * A controller instance with open properties/methods
@@ -64,7 +64,7 @@ export class ControllerRoute<T> extends BaseRoute {
     methodName?: string,
   ) {
     const controllerName = spec['x-controller-name'] || controllerCtor.name;
-    methodName = methodName || spec['x-operation-name'];
+    methodName = methodName ?? spec['x-operation-name'];
 
     if (!methodName) {
       throw new Error(
@@ -90,7 +90,7 @@ export class ControllerRoute<T> extends BaseRoute {
     );
 
     this._controllerFactory =
-      controllerFactory || createControllerFactoryForClass(controllerCtor);
+      controllerFactory ?? createControllerFactoryForClass(controllerCtor);
     this._controllerCtor = controllerCtor;
     this._controllerName = controllerName || controllerCtor.name;
     this._methodName = methodName;
@@ -138,7 +138,9 @@ export class ControllerRoute<T> extends BaseRoute {
       );
     }
     // Invoke the method with dependency injection
-    return invokeMethod(controller, this._methodName, requestContext, args);
+    return invokeMethod(controller, this._methodName, requestContext, args, {
+      source: new RouteSource(this),
+    });
   }
 }
 

package/src/router/external-express-routes.ts

@@ -9,11 +9,10 @@ import {
   OperationObject,
   SchemasObject,
 } from '@loopback/openapi-v3';
-import * as express from 'express';
-import {RequestHandler} from 'express';
+import express, {RequestHandler} from 'express';
 import {PathParams} from 'express-serve-static-core';
-import * as HttpErrors from 'http-errors';
-import * as onFinished from 'on-finished';
+import HttpErrors from 'http-errors';
+import onFinished from 'on-finished';
 import {ServeStaticOptions} from 'serve-static';
 import {promisify} from 'util';
 import {RequestContext} from '../request-context';

package/src/router/handler-route.ts

@@ -7,7 +7,7 @@ import {Context, invokeMethodWithInterceptors} from '@loopback/context';
 import {OperationObject} from '@loopback/openapi-v3';
 import {RestBindings} from '../keys';
 import {OperationArgs, OperationRetval} from '../types';
-import {BaseRoute} from './base-route';
+import {BaseRoute, RouteSource} from './base-route';
 
 export class Route extends BaseRoute {
   constructor(
@@ -33,6 +33,12 @@ export class Route extends BaseRoute {
   ): Promise<OperationRetval> {
     // Use `invokeMethodWithInterceptors` to invoke the handler function so
     // that global interceptors are applied
-    return invokeMethodWithInterceptors(requestContext, this, '_handler', args);
+    return invokeMethodWithInterceptors(
+      requestContext,
+      this,
+      '_handler',
+      args,
+      {source: new RouteSource(this)},
+    );
   }
 }

package/src/router/openapi-path.ts

@@ -13,42 +13,37 @@ import {parse} from 'path-to-regexp';
  * allows `[A-Za-z0-9_]`
  */
 const POSSIBLE_VARNAME_PATTERN = /\{([^\}]+)\}/g;
-const INVALID_VARNAME_PATTERN = /\{([^\}]*[^\w\}][^\}]*)\}/;
+const VALID_VARNAME_PATTERN = /^[A-Za-z0-9_]+$/;
 
 /**
  * Validate the path to be compatible with OpenAPI path template. No parameter
  * modifier, custom pattern, or unnamed parameter is allowed.
  */
 export function validateApiPath(path = '/') {
-  let tokens = parse(path);
-  if (tokens.some(t => typeof t === 'object')) {
-    throw new Error(
-      `Invalid path template: '${path}'. Please use {param} instead of ':param'`,
-    );
-  }
-
-  const invalid = path.match(INVALID_VARNAME_PATTERN);
-  if (invalid) {
-    throw new Error(
-      `Invalid parameter name '${invalid[1]}' found in path '${path}'`,
-    );
-  }
-
-  const regexpPath = toExpressPath(path);
-  tokens = parse(regexpPath);
+  const tokens = parse(path);
   for (const token of tokens) {
     if (typeof token === 'string') continue;
-    if (typeof token.name === 'number') {
-      // Such as /(.*)
-      throw new Error(`Unnamed parameter is not allowed in path '${path}'`);
-    }
-    if (
-      (token.optional || token.repeat || token.pattern !== '[^\\/]+?') &&
-      // Required by path-to-regexp@3.x
-      token.prefix === '/'
-    ) {
-      // Such as /:foo*, /:foo+, /:foo?, or /:foo(\\d+)
-      throw new Error(`Parameter modifier is not allowed in path '${path}'`);
+    if (typeof token === 'object') {
+      const name = token.name;
+      if (typeof name === 'string' && name !== '') {
+        throw new Error(
+          `Invalid path template: '${path}'. Please use {${name}} instead of ':${name}'`,
+        );
+      }
+      if (typeof name === 'number') {
+        throw new Error(`Unnamed parameter is not allowed in path '${path}'`);
+      }
+      const valid = token.prefix.match(VALID_VARNAME_PATTERN);
+      if (!valid) {
+        throw new Error(
+          `Invalid parameter name '${token.prefix}' found in path '${path}'`,
+        );
+      }
+      if (['?', '+', '*'].includes(token.modifier)) {
+        throw new Error(
+          `Parameter modifier '{${token.prefix}}${token.modifier}' is not allowed in path '${path}`,
+        );
+      }
     }
   }
   return path;
@@ -68,5 +63,5 @@ export function getPathVariables(path: string) {
 export function toExpressPath(path: string) {
   // Convert `.` to `\\.` so that path-to-regexp will treat it as the plain
   // `.` character
-  return path.replace(POSSIBLE_VARNAME_PATTERN, ':$1').replace('.', '\\.');
+  return path.replace(POSSIBLE_VARNAME_PATTERN, '{:$1}').replace('.', '\\.');
 }

package/src/router/router-base.ts

@@ -109,7 +109,7 @@ export abstract class BaseRouter implements RestRouter {
  */
 function normalizeVerb(verb: string) {
   // Use lower case, default to `get`
-  return (verb && verb.toLowerCase()) || 'get';
+  return verb?.toLowerCase() || 'get';
 }
 
 /**

package/src/router/routing-table.ts

@@ -9,9 +9,9 @@ import {
   ParameterObject,
   PathObject,
 } from '@loopback/openapi-v3';
-import * as assert from 'assert';
-import * as debugFactory from 'debug';
-import * as HttpErrors from 'http-errors';
+import assert from 'assert';
+import debugFactory from 'debug';
+import HttpErrors from 'http-errors';
 import {inspect} from 'util';
 import {Request} from '../types';
 import {
@@ -57,7 +57,7 @@ export class RoutingTable {
 
     debug('Registering Controller with API %s', inspect(spec, {depth: null}));
 
-    const basePath = spec.basePath || '/';
+    const basePath = spec.basePath ?? '/';
     for (const p in spec.paths) {
       for (const verb in spec.paths[p]) {
         const opSpec: OperationObject = spec.paths[p][verb];
@@ -154,6 +154,6 @@ export class RoutingTable {
 
 function describeOperationParameters(opSpec: OperationObject) {
   return ((opSpec.parameters as ParameterObject[]) || [])
-    .map(p => (p && p.name) || '')
+    .map(p => p?.name || '')
     .join(', ');
 }

package/src/router/trie-router.ts

@@ -42,7 +42,7 @@ export class TrieRouter extends BaseRouter {
       const route = found.node.value!;
       if (route) {
         debug('Route found: %s', inspect(route, {depth: 5}));
-        return createResolvedRoute(route, found.params || {});
+        return createResolvedRoute(route, found.params ?? {});
       }
     }
     return undefined;

package/src/types.ts

@@ -5,7 +5,7 @@
 
 import {Binding, BoundValue} from '@loopback/context';
 import {ReferenceObject, SchemaObject} from '@loopback/openapi-v3';
-import * as ajv from 'ajv';
+import ajv from 'ajv';
 import {
   Options,
   OptionsJson,

package/src/validation/request-body.validator.ts

@@ -10,10 +10,10 @@ import {
   SchemaObject,
   SchemasObject,
 } from '@loopback/openapi-v3';
-import * as AJV from 'ajv';
-import * as debugModule from 'debug';
-import * as _ from 'lodash';
-import * as util from 'util';
+import AJV from 'ajv';
+import debugModule from 'debug';
+import _ from 'lodash';
+import util from 'util';
 import {HttpErrors, RequestBody, RestHttpErrors} from '..';
 import {RequestBodyValidationOptions, SchemaValidatorCache} from '../types';
 
@@ -38,7 +38,7 @@ export function validateRequestBody(
   globalSchemas: SchemasObject = {},
   options: RequestBodyValidationOptions = {},
 ) {
-  const required = requestBodySpec && requestBodySpec.required;
+  const required = requestBodySpec?.required;
 
   if (required && body.value == null) {
     const err = Object.assign(
@@ -125,7 +125,7 @@ function validateValueAgainstSchema(
 ) {
   let validate: AJV.ValidateFunction | undefined;
 
-  const cache = options.compiledSchemaCache || DEFAULT_COMPILED_SCHEMA_CACHE;
+  const cache = options.compiledSchemaCache ?? DEFAULT_COMPILED_SCHEMA_CACHE;
   const key = getKeyForOptions(options);
 
   let validatorMap: Map<string, AJV.ValidateFunction> | undefined;
@@ -136,7 +136,7 @@ function validateValueAgainstSchema(
 
   if (!validate) {
     validate = createValidator(schema, globalSchemas, options);
-    validatorMap = validatorMap || new Map();
+    validatorMap = validatorMap ?? new Map();
     validatorMap.set(key, validate);
     cache.set(schema, validatorMap);
   }

package/src/writer.ts

@@ -31,7 +31,7 @@ export function writeResultToResponse(
   }
 
   const isStream =
-    result instanceof Readable || typeof (result && result.pipe) === 'function';
+    result instanceof Readable || typeof result?.pipe === 'function';
 
   if (isStream) {
     response.setHeader('Content-Type', 'application/octet-stream');