So erstellen und verwenden Sie einen Decorator und Middleware in NestJS

Dekoratoren und Middleware sind das A und O von NestJS – Werkzeuge, die Ihr Leben entweder unglaublich einfach oder leicht überwältigend machen können, je nachdem, wie Sie an sie herangehen.

Lassen Sie uns heute durch die Erstellung eines benutzerdefinierten Dekorators und einer Middleware für die Benutzerauthentifizierung gehen und dabei die Dinge leicht und unkompliziert halten. Schnapp dir deinen Kaffee und lass uns eintauchen!

1. Die Schnittstelle

Zuerst definieren wir eine Schnittstelle für unser Benutzerobjekt.

Dies gewährleistet die Typensicherheit und sorgt dafür, dass unsere IDE zufrieden ist (und wer liebt nicht eine glückliche IDE?).

export interface IUser {
  id: string;
  name: string;
  primaryEmail: string;
  phoneNumber: string | null;
  countryCode: string | null;
  dob: Date | null;
  createdAt: Date;
  updatedAt?: Date;
  deletedAt?: Date | null;
}

---

2. Erstellen eines benutzerdefinierten Dekorators

Benutzerdefinierte Dekoratoren sind wie die coolen Kids in einer NestJS-Anwendung.

Hier erstellen wir eines, um Benutzermetadaten aus dem Anforderungsobjekt abzurufen.

import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { IUser } from '../interface/user.interface';

export const UserMetadata = createParamDecorator(
  (_data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user as IUser;
  },
);

Das ist es! Dieser Dekorator kann jetzt verwendet werden, um Benutzerinformationen direkt in Ihre Controller-Methoden abzurufen.

3. Erstellen der Auth-Middleware

Jetzt erstellen wir einen AuthGuard, um unsere Endpunkte wie einen virtuellen Türsteher zu schützen.

import {
  CanActivate,
  ExecutionContext,
  ForbiddenException,
  Injectable
} from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { verify } from 'jsonwebtoken';
import { Observable } from 'rxjs';
import { IS_PUBLIC_KEY } from '../constant/core';
import { IUser } from '../interface/user.interface';

@Injectable()
export class AuthGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
  ) { }

  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
      context.getHandler(),
      context.getClass(),
    ]);
    if (isPublic) {
      return true;
    }

    const request = context.switchToHttp().getRequest();
    const headers = request.headers;

    const token = (headers['authorization'] || '').split(' ')[1];
    if (!token) {
      throw new ForbiddenException('Not Authenticated');
    }

    const jwtOpts = {
      expiresIn: '1h', // Replace with env vars in real use
      audience: 'your-audience',
      algorithm: 'HS256',
      issuer: 'your-issuer',
    };

    try {
      const decoded = verify(token, "my-jwt-secret-token", {
        audience: jwtOpts.audience,
        issuer: jwtOpts.issuer,
      }) as { user: IUser };

      request.user = decoded.user;
      return true;
    } catch (err) {
      throw new ForbiddenException('Session Expired or Invalid');
    }
  }
}

4. Hinzufügen von Metadaten für öffentliche und interne Routen

Einige Routen sollten öffentlich sein (wie die Anmeldung), andere könnten intern sein.

Fügen wir dazu zwei einfache Dekoratoren hinzu.

import { SetMetadata } from '@nestjs/common';

export const IS_PUBLIC_KEY = 'isPublic';
export const IS_INTERNAL = 'isInternal';

export const Public = () => SetMetadata(IS_PUBLIC_KEY, true);
export const Internal = () => SetMetadata(IS_INTERNAL, true);

---

5. Sie in einem Controller verwenden

Schließlich erfahren Sie hier, wie Sie all dies in Ihrem Controller verwenden können.

import { Controller, Get, UseGuards } from '@nestjs/common';
import { UserMetadata } from '../decorators/user.decorator';
import { AuthGuard } from '../guards/auth.guard';
import { Public } from '../decorators/public.decorator';

@Controller('users')
export class UserController {

  @Public()
  @Get('login')
  login() {
    return { message: 'Login endpoint (public)' };
  }

  @UseGuards(AuthGuard)
  @Get('profile')
  getProfile(@UserMetadata() user: IUser) {
    return {
      message: 'User Profile',
      user,
    };
  }
}

Zusammenfassung

Und da haben Sie es! Sie haben einen benutzerdefinierten Dekorator, Middleware und Metadaten-Dekoratoren erstellt, um öffentliche Routen zu verwalten.

Mit diesen Tools können Sie sichere und organisierte APIs in NestJS erstellen.

Wenn Ihnen das zu viel vorkommt, denken Sie daran – selbst Rom wurde nicht an einem Tag erbaut, aber Ihre APIs können definitiv schneller skalieren!

Fühlen Sie sich frei, diese Snippets zu optimieren und damit zu experimentieren.

Mit NestJS sind keine Grenzen gesetzt! ?

---

Ich habe an einem äußerst praktischen Tool namens LiveAPI gearbeitet.

Es wurde entwickelt, um die API-Dokumentation für Entwickler mühelos zu gestalten.

Mit LiveAPI können Sie schnell eine interaktive API-Dokumentation erstellen, die es Benutzern ermöglicht, APIs direkt über den Browser auszuführen.

Wenn Sie es satt haben, manuell Dokumente für Ihre APIs zu erstellen, könnte Ihnen dieses Tool das Leben erleichtern.

Von Lama2 zu LiveAPI: Erstellen einer äußerst praktischen API-Dokumentation (Teil II)

Athreya alias Maneshwar für Hexmos ・ 14. Dezember 2024

#webdev #javascript #Programmierung #Anfänger

Das obige ist der detaillierte Inhalt vonSo erstellen und verwenden Sie einen Decorator und Middleware in NestJS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!