Sådan opbygges en typesikker URL-forkorter i NodeJS med NestJS

Sådan opbygges en typesikker URL-forkorter i NodeJS med NestJS

Introduktion

I den moderne verden er URL-forkortere blevet et uundværligt værktøj til at håndtere lange og rodede webadresser. De giver mulighed for at konvertere lange URL’er til kortere og mere håndterbare versioner, hvilket gør det lettere at dele og huske dem. I denne artikel vil vi udforske, hvordan man opbygger en typesikker URL-forkorter i NodeJS ved hjælp af NestJS-rammeværket.

NestJS er et populært NodeJS-rammeværk til opbygning af skalerbare og vedligeholdelige webservices. Det implementerer et modulært designmønster og giver en række værktøjer til at håndtere datavalidering, routing og exception handling. Ved at drage fordel af NestJS’s funktioner kan vi opbygge en robust og sikker URL-forkorter, der imødekommer behovene i moderne webapplikationer.

H2 Opsætning af NestJS-projektet

Det første trin i at opbygge en URL-forkorter er at opsætte et NestJS-projekt. Du kan gøre dette ved at bruge den officielle NestJS-CLI (kommandolinjegrænseflade):


nest new url-shortener


Dette vil generere et skeletprojekt med en grundlæggende app-modul og hovedfil.

H2 Oprettelse af URL-entiteten

Det næste trin er at definere URL-entiteten, der repræsenterer de forkortede URL’er i vores database. Vi bruger TypeScript til at definere vores entiteter, hvilket giver os mulighed for at oprette typesikre modeller:

typescript
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Url {
@PrimaryGeneratedColumn()
id: number;

@Column()
longUrl: string;

@Column()
shortUrl: string;
}


Entiteten definerer tre kolonner: id (primær nøgle), longUrl (den oprindelige lange URL) og shortUrl (den forkortede version).

H2 Definer URL-tjenesten

URL-tjenesten er ansvarlig for at håndtere URL-forkortning og -udvidelse. Vi bruger NestJS’s @Injectable()-dekoration til at oprette en serviceklasse:

typescript
import { Injectable } from '@nestjs/common';
import { Url } from './url.entity';
import { Repository } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';

@Injectable()
export class UrlService {
constructor(
@InjectRepository(Url)
private readonly urlRepository: Repository<Url>,
) {}

async shorten(longUrl: string): Promise<Url> {
// Implementer forkortelse af URL'en her
}

async expand(shortUrl: string): Promise<Url> {
// Implementer udvidelse af URL'en her
}
}


I denne tjenesteklasse injicerer vi UrlRepository ved hjælp af @InjectRepository()-dekorationen. Dette giver os adgang til TypeORM-repositoriet til håndtering af databaseoperationer relateret til Url-entiteten.

H2 Implemente forkortelse og udvidelse

I UrlService skal vi implementere shorten()– og expand()-metoderne for at håndtere forkortelse og udvidelse af URL’er. Vi kan bruge en bibliotek til URL-forkortning såsom shortid eller nanoid til at generere unikke shortcodes.

typescript
import { shortid } from 'shortid';

async shorten(longUrl: string): Promise<Url> {
const shortcode = shortid.generate();
const shortUrl = ${process.env.BASE_URL}/${shortcode};

const url = new Url();
url.longUrl = longUrl;
url.shortUrl = shortUrl;

return this.urlRepository.save(url);
}


typescript
async expand(shortUrl: string): Promise<Url> {
return this.urlRepository.findOne({ where: { shortUrl } });
}


H2 Opret URL-controlleren

URL-controlleren er ansvarlig for at eksponere API-slutpunkter til URL-forkortning og -udvidelse. Vi bruger NestJS’s @Controller()– og @Post()-dekorationer til at definere vores controller:

typescript
import { Controller, Post, Body } from '@nestjs/common';
import { UrlService } from './url.service';

@Controller('url')
export class UrlController {
constructor(private readonly urlService: UrlService) {}

@Post('shorten')
async shorten(@Body() body: { longUrl: string }): Promise<Url> {
return this.urlService.shorten(body.longUrl);
}

@Post('expand')
async expand(@Body() body: { shortUrl: string }): Promise<Url> {
return this.urlService.expand(body.shortUrl);
}
}


H2 Implementering af datavalidering

Datavalidering er afgørende for at sikre, at vores URL-forkorter kun accepterer gyldige indgange. Vi kan bruge NestJS’s indbyggede datavalideringsmekanisme til at udføre serversidevalidering:

typescript
import { Body, ValidationPipe } from '@nestjs/common';

@Post('shorten')
async shorten(@Body(new ValidationPipe()) body: { longUrl: string }): Promise<Url> {
// Implementer forkortelse af URL'en her
}


Vi bruger ValidationPipe til at anvende datavalideringsregler til indgående HTTP-anmodninger.

H2 Konfiguration af miljøvariabler

Vi har brug for at konfigurere miljøvariabler for at angive base-URL’en til vores forkorter. Vi kan gøre dette ved at oprette en .env-fil i projektroden:


BASE_URL=https://example.com


Vi kan derefter få adgang til disse miljøvariabler i vores kode ved hjælp af process.env:

typescript
const shortUrl = ${process.env.BASE_URL}/${shortcode};


Konklusion

I denne artikel har vi gennemgået, hvordan man opbygger en typesikker URL-forkorter i NodeJS ved hjælp af NestJS-rammeværket. Vi har defineret en URL-entitet, skabt en URL-tjeneste til at håndtere forkortelse og udvidelse, oprettet en URL-controller til at eksponere API-slutpunkter og implementeret datavalidering for at sikre integriteten af indgående data. Ved at følge denne vejledning kan du opbygge en robust og vedligeholdelig URL-forkorter, der passer til behovene i moderne webapplikationer.

Ofte stillede spørgsmål

1. Hvad er fordelene ved at bruge NestJS til at bygge en URL-forkorter?
– Typesikkerhed
– Modulært design
– Indbygget datavalidering
– Enkel og hurtig udvikling

2. Hvad er de vigtigste overvejelser ved opbygning af en URL-forkorter?
– Datavalidering
– Unikke shortcodes
– Databasedesign
– Skalerbarhed

3. Hvordan sikrer jeg, at shortcodes er unikke?
– Brug af et bibliotek som shortid eller nanoid
– Implementering af en databasestøtte til unikke værdier

4. Hvordan håndterer jeg lange URL’er, der er for lange til at forkortet?
– Angiv en maksimal længde for indgående URL’er
– Giv en fejlbesked, der angiver, at URL’en er for lang

5. Hvordan måler jeg effektiviteten af min URL-forkorter?
– Spor antallet af forkortelser og udvidelser
– Analyserer klikfrekvenserne fra forkortede URL’er
– Få feedback fra brugere