@loopback/rest 6.1.0 → 8.0.0

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.application.ts

@@ -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.server.ts

@@ -111,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
@@ -170,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
@@ -206,6 +211,7 @@ export class RestServer extends BaseMiddlewareRegistry
     config: RestServerConfig = {},
   ) {
     super(app);
+    this.scope = BindingScope.SERVER;
 
     this.config = resolveRestServerConfig(config);
 
@@ -978,10 +984,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

@@ -4,11 +4,11 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {
-  bind,
   BindingScope,
   config,
   Context,
   inject,
+  injectable,
   ValueOrPromise,
 } from '@loopback/core';
 import {
@@ -185,7 +185,7 @@ export namespace RestMiddlewareGroups {
 /**
  * A sequence implementation using middleware chains
  */
-@bind({scope: BindingScope.SINGLETON})
+@injectable({scope: BindingScope.SINGLETON})
 export class MiddlewareSequence implements SequenceHandler {
   private middlewareView: MiddlewareView;
 

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/validation/ajv-factory.provider.ts

@@ -4,16 +4,17 @@
 // License text available at https://opensource.org/licenses/MIT
 
 import {
-  bind,
   BindingScope,
   filterByTag,
   inject,
+  injectable,
   Provider,
 } from '@loopback/core';
 import AjvCtor from 'ajv';
 import debugModule from 'debug';
 import {RestBindings, RestTags} from '../keys';
 import {AjvFactory, AjvFormat, AjvKeyword, ValidationOptions} from '../types';
+import {openapiFormats} from './openapi-formats';
 
 const debug = debugModule('loopback:rest:ajv');
 
@@ -29,7 +30,7 @@ export const DEFAULT_AJV_VALIDATION_OPTIONS: ValidationOptions = {
 /**
  * A provider class that instantiate an AJV instance
  */
-@bind({scope: BindingScope.SINGLETON})
+@injectable({scope: BindingScope.SINGLETON})
 export class AjvFactoryProvider implements Provider<AjvFactory> {
   constructor(
     @inject(
@@ -57,8 +58,6 @@ export class AjvFactoryProvider implements Provider<AjvFactory> {
         jsonPointers: true,
         // nullable: support keyword "nullable" from Open API 3 specification.
         nullable: true,
-        // Allow OpenAPI spec binary format
-        unknownFormats: ['binary'],
         ...validationOptions,
       };
 
@@ -84,12 +83,17 @@ export class AjvFactoryProvider implements Provider<AjvFactory> {
         });
       }
 
+      for (const format of openapiFormats) {
+        ajvInst.addFormat(format.name, format);
+      }
+
       if (this.formats) {
         this.formats.forEach(format => {
           debug('Adding Ajv format %s', format.name);
           ajvInst.addFormat(format.name, format);
         });
       }
+
       return ajvInst;
     };
   }

package/src/validation/openapi-formats.ts

@@ -0,0 +1,92 @@
+// Copyright IBM Corp. 2020. All Rights Reserved.
+// Node module: @loopback/rest
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+
+import {AjvFormat} from '../types';
+
+/**
+ * int32: [-2147483648, 21474836 47]
+ */
+export const int32Format: AjvFormat = {
+  name: 'int32',
+  type: 'number',
+  validate: (value: number) => {
+    return (
+      Number.isInteger(value) && value >= -2147483648 && value <= 2147483647
+    );
+  },
+  async: false,
+};
+
+/**
+ * int64: [-9223372036854775808, 9223372036854775807]
+ */
+export const int64Format: AjvFormat = {
+  name: 'int64',
+  type: 'number',
+  validate: (value: number) => {
+    const max = Number.MAX_SAFE_INTEGER; // 9007199254740991
+    const min = Number.MIN_SAFE_INTEGER; // -9007199254740991
+    return Number.isInteger(value) && value >= min && value <= max;
+  },
+  async: false,
+};
+
+/**
+ * float: [-2^128, 2^128]
+ */
+export const floatFormat: AjvFormat = {
+  name: 'float',
+  type: 'number',
+  validate: (value: number) => {
+    return value >= -Math.pow(2, 128) && value <= Math.pow(2, 128);
+  },
+  async: false,
+};
+
+/**
+ * double: [-2^1024, 2^1024]
+ */
+export const doubleFormat: AjvFormat = {
+  name: 'double',
+  type: 'number',
+  validate: (value: number) => {
+    const max = Number.MAX_VALUE; // 1.7976931348623157e+308
+    const min = -Number.MAX_VALUE; // -1.7976931348623157e+308
+    return value >= min && value <= max;
+  },
+  async: false,
+};
+
+/**
+ * Base64 encoded string
+ */
+export const byteFormat: AjvFormat = {
+  name: 'byte',
+  type: 'string',
+  validate: (value: string) => {
+    const base64 = Buffer.from(value, 'base64').toString('base64');
+    return value === base64;
+  },
+  async: false,
+};
+
+/**
+ * Binary string
+ */
+export const binaryFormat: AjvFormat = {
+  name: 'binary',
+  type: 'string',
+  validate: (value: string) => true,
+  async: false,
+};
+
+export const openapiFormats: AjvFormat[] = [
+  int32Format,
+  int64Format,
+  floatFormat,
+  doubleFormat,
+  byteFormat,
+  binaryFormat,
+];

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

@@ -118,11 +118,11 @@ function getKeyForOptions(
 }
 
 /**
- * Validate the request body data against JSON schema.
- * @param body - The request body data.
+ * Validate the value against JSON schema.
+ * @param value - The data value.
  * @param schema - The JSON schema used to perform the validation.
  * @param globalSchemas - Schema references.
- * @param options - Request body validation options.
+ * @param options - Value validation options.
  */
 export async function validateValueAgainstSchema(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -155,11 +155,11 @@ export async function validateValueAgainstSchema(
   let validationErrors: ajv.ErrorObject[] = [];
   try {
     const validationResult = await validate(value);
-    // When value is optional & values is empty / null, ajv returns null
-    if (validationResult || validationResult === null) {
-      debug(`Value from ${options.source} passed AJV validation.`);
-      return;
-    }
+    debug(
+      `Value from ${options.source} passed AJV validation.`,
+      validationResult,
+    );
+    return validationResult;
   } catch (error) {
     validationErrors = error.errors;
   }