Como construir um encurtador de URL com segurança de tipos em NodeJS com NestJS
Introdução
Em um mundo digital em constante evolução, os encurtadores de URL se tornaram ferramentas essenciais para compartilhar links longos e complexos de forma sucinta e fácil de lembrar. Seja para campanhas de marketing, postagens em mídias sociais ou mensagens pessoais, os encurtadores de URL fornecem uma solução conveniente para condensar e personalizar URLs, tornando-os mais acessíveis e apresentáveis.
Neste artigo, mergulharemos no desenvolvimento de um encurtador de URL seguro e de tipo seguro usando NodeJS e o framework NestJS. Ao aproveitar os recursos avançados de tipagem do Typescript e a arquitetura modular do NestJS, criaremos um aplicativo robusto e escalável que garante a segurança e a integridade dos URLs encurtados.
O que é segurança de tipo?
A segurança de tipo é um recurso de linguagem que verifica se os tipos de dados são usados de acordo com as definições definidas. Ele garante que os valores atribuídos às variáveis sejam compatíveis com o tipo de dados esperado, evitando erros de tempo de execução e melhorando a confiabilidade do código. O Typescript, uma superconjunto do JavaScript, oferece recursos abrangentes de segurança de tipo, permitindo que os desenvolvedores definam e validem os tipos de dados com precisão.
Por que usar NestJS?
NestJS é um framework NodeJS moderno e de alto desempenho que adota os princípios da arquitetura orientada a objetos (OOP) e programação funcional. Ele fornece uma estrutura modular e recursos prontos para uso, como injeção de dependência, roteamento e manipulação de exceções, agilizando o processo de desenvolvimento e promovendo a manutenibilidade do código.
Construindo o encurtador de URL com NestJS
Criando um novo projeto NestJS
1. Instale o NestJS globalmente: npm install -g @nestjs/cli
2. Crie um novo projeto NestJS: nest new url-shortener
3. Navegue até o diretório do projeto: cd url-shortener
Definindo as entidades
Criaremos duas entidades: Url e ShortUrl. A entidade Url representa o URL original longo, enquanto a entidade ShortUrl representa o URL encurtado gerado.
typescript
// url.entity.ts
@Entity()
export class Url {
@PrimaryGeneratedColumn()
id: number;
@Column()
originalUrl: string;
@Column()
shortUrl: string;
@CreateDateColumn()
createdAt: Date;
@UpdateDateColumn()
updatedAt: Date;
}
// short-url.entity.ts
@Entity()
export class ShortUrl {
@PrimaryGeneratedColumn()
id: number;
@Column()
originalUrl: string;
@Column()
shortUrl: string;
@CreateDateColumn()
createdAt: Date;
@UpdateDateColumn()
updatedAt: Date;
}
Definindo os serviços
Criaremos dois serviços: UrlService e ShortUrlService. O serviço UrlService será responsável por manipular URLs originais e gerar URLs encurtados. O serviço ShortUrlService será responsável por recuperar e redirecionar para URLs encurtados.
typescript
// url.service.ts
@Injectable()
export class UrlService {
constructor(
@InjectRepository(Url) private urlRepository: Repository<Url>,
) {}
async create(originalUrl: string): Promise<ShortUrl> {
// Gere um código curto exclusivo
const shortUrl = this.generateShortUrl();
// Crie uma nova entidade Url
const url = new Url();
url.originalUrl = originalUrl;
url.shortUrl = shortUrl;
// Salve a nova entidade Url
await this.urlRepository.save(url);
// Retorne o URL curto gerado
return {
originalUrl,
shortUrl,
};
}
// Outros métodos...
}
// short-url.service.ts
@Injectable()
export class ShortUrlService {
constructor(
@InjectRepository(ShortUrl) private shortUrlRepository: Repository<ShortUrl>,
) {}
async findByShortUrl(shortUrl: string): Promise<Url | undefined> {
return await this.shortUrlRepository.findOne({ where: { shortUrl } });
}
// Outros métodos...
}
Definindo os controladores
Criaremos dois controladores: UrlController e ShortUrlController. O controlador UrlController será responsável por criar e gerenciar URLs encurtados. O controlador ShortUrlController será responsável por redirecionar para URLs encurtados.
typescript
// url.controller.ts
@Controller('url')
export class UrlController {
constructor(private urlService: UrlService) {}
@Post()
async createUrl(@Body() body: { originalUrl: string }): Promise<ShortUrl> {
return await this.urlService.create(body.originalUrl);
}
// Outros métodos...
}
// short-url.controller.ts
@Controller('s/:shortUrl')
export class ShortUrlController {
constructor(private shortUrlService: ShortUrlService) {}
@Get()
async redirect(@Param('shortUrl') shortUrl: string): Promise<void> {
const url = await this.shortUrlService.findByShortUrl(shortUrl);
if (url) {
res.redirect(url.originalUrl);
} else {
res.sendStatus(404);
}
}
}
Conclusão
Seguindo as etapas descritas neste artigo, você pode construir com sucesso um encurtador de URL seguro e de tipo seguro usando NodeJS e NestJS. Ao aproveitar os recursos avançados de tipagem do Typescript e a arquitetura modular do NestJS, você criou um aplicativo robusto e escalável que garante a integridade e a segurança dos URLs encurtados.
O uso de segurança de tipo ajuda a prevenir erros de tempo de execução, garantindo que os tipos de dados sejam usados conforme o esperado. O NestJS fornece uma base sólida para o desenvolvimento de aplicativos NodeJS, oferecendo uma variedade de ferramentas e recursos que simplificam o processo de desenvolvimento e promovem boas práticas de codificação.
FAQs
1. Quais são as vantagens de usar segurança de tipo?
* Prevenção de erros de tempo de execução
* Maior confiabilidade do código
* Melhor legibilidade e manutenção do código
2. Por que usar NestJS para desenvolver um encurtador de URL?
* Arquitetura modular para melhor organização e manutenção
* Injeção de dependência para desacoplamento e testabilidade
* Recursos prontos para uso, como roteamento e manipulação de exceções
3. Como funciona a geração de URLs curtos?
O aplicativo pode gerar URLs curtos usando técnicas como hash de URL ou codificação Base64. O algoritmo usado para gerar URLs curtos deve garantir a exclusividade.
4. Como o aplicativo garante a segurança dos URLs encurtados?
O aplicativo pode usar criptografia para proteger URLs encurtados, evitando que usuários não autorizados acessem URLs originais.
5. Como o aplicativo lida com URLs duplicados?
O aplicativo pode verificar se um URL original já existe antes de gerar um novo URL curto. Se um URL original duplicado for encontrado, o aplicativo pode retornar o URL curto existente.
6. Quais são as limitações do aplicativo?
O aplicativo pode ter limitações na duração dos URLs curtos gerados ou no número de URLs que podem ser salvos.
7. Como o aplicativo lida com URLs inválidos?
O aplicativo pode validar o formato do URL original antes de gerar um URL curto. URLs inválidos podem retornar um erro.
8. Como o aplicativo pode ser escalado para lidar com um grande volume de URLs?
O aplicativo pode ser escalado usando técnicas como balanceamento de carga ou implantação em vários servidores.
9. Quais são os recursos adicionais que podem ser adicionados ao aplicativo?
* Suporte para URLs personalizados
* Gerenciamento de expiração de URL
* Rastreamento e análise de cliques