When the nestjs interface appears to be missing a defined method

Question

When the nestjs interface appears to be missing a defined method

Upon reviewing the code at this link:

https://github.com/nestjs/nest/tree/master/packages/common

One can see that the interface ArgumentsHost has been defined, but the contents of its methods are not explicitly defined.

However, when looking at the following code snippet:

https://docs.nestjs.com/exception-filters

It is evident that ArgumentsHost is used and the method switchToHttp() functions correctly.

How is it that these methods work without having specific definitions? Is there a key point that I am missing as a beginner in this context? Any insights or opinions would be greatly appreciated.

Thank you.

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';

@Catch(HttpException)
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();
    const status = exception.getStatus();

    response
      .status(status)
      .json({
        statusCode: status,
        timestamp: new Date().toISOString(),
        path: request.url,
      });
  }
}

typescript nestjs

Answer 1

Answer №1

This concept is not exclusive to Nest but rather applies to TypeScript (and other languages) in a broader sense. When you define an interface, you are essentially specifying a type, and when your catch method requires a second argument, it must adhere to that type. In simple terms, any value with the correct structure can be utilized as the second argument.

In the case of Nest library, it is responsible for providing a specific value to your defined catch method, ensuring it conforms to the ArgumentsHost interface. For instance, you can refer to the implementation of ExecutionContextHost as an example of such an instance.

This approach is a versatile and powerful way to create functions that only require inputs with a particular structure, such as specific properties or methods.

For instance, consider a graphics library with a render function that accepts an array of shape objects to draw on the screen. The shapes can vary greatly, like squares, circles, or even unique shapes, as long as they have the necessary drawing method:

function render(shapes: Drawable[]) {
  shapes.forEach(shape => shape.draw());
}

interface Drawable {
  draw: () => void;
}

Hence, any object with a compatible draw method can be included in the array of arguments for render, regardless of its other properties.

In conclusion, the draw method is not explicitly dictated by the Drawable interface; rather, the interface acts as a filter, allowing only certain elements to pass through.

The draw method is implemented by concrete instances of the interface, such as:

class Square extends Drawable {
  public x: number;
  public y: number;
  public sideLength: number;

  draw() {
    // Drawing logic here
  }
}

Answer 2

This concept is not exclusive to Nest but rather applies to TypeScript (and other languages) in a broader sense. When you define an interface, you are essentially specifying a type, and when your catch method requires a second argument, it must adhere to that type. In simple terms, any value with the correct structure can be utilized as the second argument.

In the case of Nest library, it is responsible for providing a specific value to your defined catch method, ensuring it conforms to the ArgumentsHost interface. For instance, you can refer to the implementation of ExecutionContextHost as an example of such an instance.

This approach is a versatile and powerful way to create functions that only require inputs with a particular structure, such as specific properties or methods.

For instance, consider a graphics library with a render function that accepts an array of shape objects to draw on the screen. The shapes can vary greatly, like squares, circles, or even unique shapes, as long as they have the necessary drawing method:

function render(shapes: Drawable[]) {
  shapes.forEach(shape => shape.draw());
}

interface Drawable {
  draw: () => void;
}

Hence, any object with a compatible draw method can be included in the array of arguments for render, regardless of its other properties.

In conclusion, the draw method is not explicitly dictated by the Drawable interface; rather, the interface acts as a filter, allowing only certain elements to pass through.

The draw method is implemented by concrete instances of the interface, such as:

class Square extends Drawable {
  public x: number;
  public y: number;
  public sideLength: number;

  draw() {
    // Drawing logic here
  }
}

When the nestjs interface appears to be missing a defined method

Answer №1

Similar questions

Retrieve the raw text from the input field instead of the date object

Unraveling nested elements with the array map() method in Angular2 and Typescript: Fixing the issue of undefined property reference while mapping

When using TypeORM's save() method with an array of objects, the @PrimaryColumn() annotations are ignored, resulting

It appears that Jest is having trouble comprehending the concept of "import type"

Higher-Order Component integrated with HTMLElement

Achieving Jest integration with Angular 9 in a Storybook setup

The incredible power of the MongoDB $inc field

Can all intervals set within NGZone be cleared?

A specialized type that guarantees a string union includes a particular string literal

Can you conduct testing on Jest tests?

Having trouble moving to a different component in Angular?

What is the best way to sort through an Array of photo filenames?

Tips for effectively handling the data received from a webservice when logging into a system

Exploring the use of a customizable decorator in Typescript for improved typing

Encountering issues with compiling files in react app using webpack, failing to compile as anticipated

Is there a way to exclusively view references of a method override in a JS/TS derived class without any mentions of the base class method or other overrides in VS Code?

Encountering a Node-gyp rebuild issue while integrating NGRX into an Angular application on Mac OS

What is the best way to utilize the `Headers` iterator within a web browser?

The existence of useRef.current is conditional upon its scope, and it may be null in certain

Creating dynamic components with constructor parameters in Angular 9