Como construir um encurtador de URL no Deno

Como construir um encurtador de URL no Deno

7 de October, 2020 0 By António César de Andrade


Neste artigo, aprenderemos o básico do Deno, como executar um programa e adotar a segurança.

Deno é o novo tempo de execução do JavaScript e TypeScript escrito em Rust. Ele oferece segurança rígida, suporte TypeScript pronto para uso, um único executável para executá-lo e um conjunto de módulos padrão revisados ​​e auditados.

Gostar npm no Node.js, os pacotes no Deno são gerenciados em um repositório de pacotes centralizado chamado X. Estaremos usando uma dessas bibliotecas, Oak, para construir um servidor baseado em API REST no Deno.

Depois de aprender o básico usando o pacote de roteador tipo Express Carvalho, vamos pular no fundo do Deno e construir um aplicativo completo.

Aqui está o que iremos configurar neste aplicativo:

  1. Mapeamento de códigos curtos de URL para terminais usando um arquivo de configuração baseado em JSON.
  2. Ter datas de expiração anexadas a cada URL para que esses redirecionamentos sejam válidos apenas por um período limitado de tempo.

0. Pré-requisitos

  1. Instale Deno de esse link.
  2. Certifique-se de conhecer o básico de JavaScript.

Embora não seja realmente necessário acompanhar este artigo, você pode verificar o vídeo do YouTube abaixo para obter uma introdução ao Deno em formato de vídeo.

Um tutorial em vídeo para configurar o Deno

Então vamos começar. 🔥

1. Como construir o roteador

Para escrever o código do lado do servidor para nosso aplicativo, usaremos o módulo Oak. Ele tem uma sintaxe semelhante à do Express para definir rotas de API.

Se olharmos para seu documentação aqui, a “Uso Básico“A seção cobre praticamente todos os casos de uso de que precisaremos em nosso roteador. Portanto, expandiremos esse código para construir nosso aplicativo.

Para testar este código, você pode criar um arquivo chamado index.ts em uma pasta e copie o código de “Uso básico” nela.

Para entender como executar arquivos TypeScript ou JavaScript no Deno, primeiro você precisa entender como o Deno executa os arquivos.

Você executa um arquivo executando o comando deno run file_name.ts ou file_name.js, seguido por um conjunto de sinalizadores fornecendo certas permissões de sistema para seu aplicativo.

Para testar isso, execute o arquivo que acabamos de criar, contendo o código de “Uso Básico”, usando o comando deno run index.ts.

Você verá que Deno reclama que você não concedeu acesso de rede ao seu aplicativo. Então, para fazer isso, você adiciona o -allow-net para o comando run. O comando será semelhante a deno run index.ts -allow-net.

O roteador escrito no código de “Uso básico” tem a seguinte aparência:

router
  .get("/", (context) => {
    context.response.body = "Hello world!";
  })
  .get("/book", (context) => {
    context.response.body = Array.from(books.values());
  })
  .get("/book/:id", (context) => {
    if (context.params && context.params.id && books.has(context.params.id)) {
      context.response.body = books.get(context.params.id);
    }
  });

Para quebrar o código acima, primeiro um router objeto foi definido. Então o get função é chamada no roteador, para definir os vários pontos de extremidade para nosso aplicativo. A respectiva lógica é definida dentro das funções de retorno de chamada.

Por exemplo, para o ponto de extremidade “/”, uma função de retorno de chamada que retorna “Hello World” no corpo da resposta foi definida. Podemos manter esse endpoint inalterado para testar se nosso servidor de aplicativos está em execução ao receber essa resposta.

Não precisamos do URL “/ book” que foi definido, então sua definição pode ser removida com segurança. Neste ponto, seu roteador deve ter a estrutura abaixo:

router
  .get("/", (context) => {
    context.response.body = "Hello world!";
  })
  .get("/book/:id", (context) => {
    if (context.params && context.params.id && books.has(context.params.id)) {
      context.response.body = books.get(context.params.id);
    }
  });

Na próxima seção, nos concentraremos em começar a construir o aplicativo real.

2. Como construir o encurtador de URL

Agora, vamos começar a construir o encurtador de URL real.

Deve redirecionar para um destino (dest), com base em um shortcode. O redirecionamento também só deve ser válido até um expiryDate, que pode ser fornecido no formato Ano-Mês-Dia.

Com base nessas suposições, vamos criar o arquivo de configuração, chamado urls.json. O formato do arquivo será:

{
  "shortcode": {
    "dest": "destination_url_string",
    "expiryDate": "YYYY-MM-DD"
  }
}

Você pode verifique o arquivo JSON aqui.

Para ler este arquivo JSON em seu código, adicione o seguinte ao topo de seu index.ts:

import { Application, Router } from "<https://deno.land/x/oak/mod.ts>";

const urls = JSON.parse(Deno.readTextFileSync("./urls.json"));

console.log(urls);

Agora, para executar o seu index.ts, você vai precisar de outra bandeira —allow-read, caso contrário, o Deno gerará um erro “permissões de leitura não fornecidas”. Seu comando final se torna deno run —allow-net —allow-read index.ts.

Depois de executar este comando, você verá o arquivo JSON sendo impresso na janela do seu terminal. Isso significa que seu programa é capaz de ler o arquivo JSON corretamente.

Se voltarmos ao exemplo de “Uso básico” que vimos acima, a rota “/ book /: id” é exatamente o que precisamos.

Em vez de “/ book /: id”, podemos usar “/ shrt /: urlid”, onde obteremos os URLs individuais com base no ID do URL (:urlid)

Substitua o código existente presente dentro da rota “/ book /: id” por este:

.get("/shrt/:urlid", (context) => {
    if (context.params && context.params.urlid && urls[context.params.urlid]) {
      context.response.redirect(urls[context.params.urlid].dest);
    } else {
      context.response.body = "404";
    }
  });

o if condição na rota faz o seguinte:

  1. Verifica se os parâmetros estão anexados à rota
  2. Verifica se o parâmetro urlid está na lista de parâmetros.
  3. Verifica se o urlid corresponde a qualquer URL em nosso JSON.

Se corresponder a todos esses, o usuário será redirecionado para o URL correto. Caso contrário, uma resposta 404 no corpo será retornada.

Para testar isso, copie esta rota em index.ts. O roteador ficará assim:

router
  .get("/", (context) => {
    context.response.body = "Hello world!";
  })
	.get("/shrt/:urlid", (context) => {
	    if (context.params && context.params.urlid && urls[context.params.urlid]) {
	      context.response.redirect(urls[context.params.urlid].dest);
	    } else {
	      context.response.body = "404";
	    }
	  });

E execute o arquivo usando deno run —allow-net —allow-read index.ts.

Se você copiou o arquivo JSON do exemplo e se for para http://localhost:8000/shrt/g, você será redirecionado para a página inicial do Google.

Por outro lado, se você usar um shortcode aleatório que não funciona na configuração do nosso URL, ele o levará para a página 404.

No entanto, você verá que nosso encurtador não reage ao vivo às alterações no arquivo JSON. Para testar isso, tente adicionar um novo redirecionamento para urls.json no mesmo formato que:

"shortcode": {
    "dest": "destination_url_string",
    "expiryDate": "YYYY-MM-DD"
  }

A razão para isso é que urls.json é lido apenas uma vez nesse início. Portanto, agora adicionaremos recarregar ao vivo em nosso servidor.

3. Como adicionar recarregamento ao vivo

Para tornar o urls Quando o objeto reage ao vivo às mudanças no arquivo JSON, simplesmente movemos a instrução read dentro de nossa rota. Isso deve ser parecido com o seguinte:

.get("/shrt/:urlid", (context) => {
  const urls = JSON.parse(Deno.readTextFileSync("./urls.json"));

  if (context.params && context.params.urlid && urls[context.params.urlid]) {
    context.response.redirect(urls[context.params.urlid].dest);
  } else {
    context.response.body = "404";
  }
});

Observe como movemos o objeto URLs dentro de nosso roteador. Agora, neste caso, o arquivo de configuração é lido toda vez que a rota é chamada, para que possa reagir ao vivo a quaisquer alterações feitas no urls.json Arquivo. Portanto, mesmo se adicionarmos ou removermos outros redirecionamentos instantaneamente, nosso código reage a eles.

4. Como adicionar uma expiração aos URLs

Para fazer nossos URLs expirarem em uma determinada data, usaremos a popular biblioteca Moment.js, que torna mais fácil trabalhar com datas.

Felizmente, também foi portado para Deno. Para entender como funciona, verifique sua documentação no link anterior.

Para usá-lo em nosso código, importe-o diretamente por meio de seu URL, como este:

import { Application, Router } from "<https://deno.land/x/oak/mod.ts>";
import { moment } from "<https://deno.land/x/moment/moment.ts>";

const router = new Router();

Para verificar a data de expiração do URL, verificamos o expiryDate chave em nosso urls objeto. Isso fará com que o código fique assim:

if (context.params && context.params.urlid && urls[context.params.urlid]) {
  if (
    urls[context.params.urlid].expiryDate > moment().format("YYYY-MM-DD")
  ) {
    context.response.redirect(urls[context.params.urlid].dest);
  } else {
    context.response.body = "Link Expired";
  }
} else {
  context.response.body = "404";
}

Dentro moment().format("YYYY-MM-DD"), obtemos a data e hora atuais usando moment(). Podemos convertê-lo para o formato “AAAA-MM-DD” (Ano-Mês-Data) usando a função .format("YYYY-MM-DD").

Comparando com o nosso expiryDate chave, podemos verificar se o URL expirou ou não.

É isso aí! Você construiu um encurtador de URL totalmente funcional no Deno. Você pode encontrar o código final no repositório GitHub aqui.

Teste-o configurando expiryDate como a data atual e fazendo outras alterações em urls.json e nosso código.

Meus pensamentos sobre Deno

Para encerrar o artigo, apresentarei minhas reflexões finais sobre deno.land.

Embora seja revigorante ver uma linguagem do lado do servidor que leva a segurança em consideração e oferece suporte ao TypeScript pronto para uso, o Deno ainda tem um longo caminho a percorrer antes de estar pronto para uso em sistemas de produção.

Por exemplo, a compilação do TypeScript ainda é muito lenta, com tempos de compilação de aproximadamente 20 segundos, mesmo para programas simples como o que acabamos de desenvolver.

Na frente de relatórios de erros, ainda é muito ruim para descrever os erros. Por exemplo, ao incorporar o código para ler urls.json na própria função, Deno não é capaz de relatar que o -allow-read bandeira não foi definida. Em vez disso, ele apenas lança um erro interno do servidor sem um erro apropriado impresso no terminal.

Qual o proximo?

Você pode melhorar suas habilidades em Deno ou Texto digitada ao construir aplicativos mais complexos como um Aplicativo de bate-papo ou um Clone da Wikipedia.

Você também pode consultar a documentação do Deno em deno.land para se familiarizar mais com o básico.

Obrigado por ler até aqui e feliz programação 🥳 !!

Deno – https://deno.land
Deno X (repositório de pacotes) – https://deno.land/x/
Oak (estrutura REST) ​​- https://deno.land/x/oak
Oak Basic Usage – https://deno.land/x/oak@v6.3.1#basic-usage
Repo final do GitHub – https://github.com/akash-joshi/deno-url-shortener



Fonte

Click to rate this post!
[Total: 0 Average: 0]