DEV Community: Deno Land Brazil

Criando API com DENO e MongoBD

Telles (@UnicornCoder) — Thu, 18 Jun 2020 15:06:21 +0000

Olá, uma das coisas divertidas que podemos começas a brincar com o Deno é criando uma API e integrar ela com o MongoDB.

Aqui vai o passo a passo de como faremos isso, mas para isso vamos usar:

abc@v1.0.0-rc2 - For router(Similar Express)
dotenvc@v1.0.0-rc2 - Variables globals in root file
mongo@v0.6.0 - MongoDB connection
typescript@3.9 - Language typed

Agora que temos nossas libs vamos para a estrutura da nossa API.
Eu pensei em algo como:

 - controllers
 -- Users
 - database
 - model
 - utils
 .env
 server.ts

SHOW ME THE CODE

Vamos começar configurando nosso server, crie um arquivo chamado server.ts na raiz do projeto e nesse arquivo a idéia é ser o mais simples possível e passar a abertura do servidor e os métodos rest, vamos analizar o código.


import { Application } from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

const app = new Application();

app
.get("/allusers", (c) => {
    return "Hello!";
  .start({ port: 4000 });

console.log(`server listening on http://localhost:4000`);

Basicamente temos uma rota com retorno "Hello!" sem segredo.

Para executar, rode no seu CLI o comando:

deno run --allow-net server.ts
Se tudo der certo vai receber mensagem "server listening on http://localhost:4000" no console e então só bater nessa URL com o Postman, Insomnia, Postwoman ou qualquer outra aplicação do tipo =)

DB Connection

conexão com o banco de dados e pra isso vamos usar o Mongodb.com ele nos da a possibilidade de criar um banco gratuito com até 500mb de capacidade.

Criado o banco, vamos para o código e aqui vamo usar o TypeeScript, mas se não quiser tipagem só usar o .js e não colocar as tipagens, bem simples.

Dentro da pasta database crie um arquivo chamado connections.ts vamos concentrar nossa conexão aqui.
Feito isso vamos fazer o import das libs, abrir conexão e passar nossas variáveis de ambiente que serão DATABASE_NAME e DATABASE_HOST

OBS. Estou utilizando a versão 0.6.0 porque a mais recente tive instabilidade para abrir conexão

import "https://deno.land/x/dotenv/load.ts";
import { init, MongoClient } from "https://deno.land/x/mongo@v0.6.0/mod.ts";

// @ts-ignore
await init();

const dbName = Deno.env.get('DATABASE_NAME') || "deno";
const dbURI = Deno.env.get('DATABASE_HOST') || "mongodb://localhost:27017";

Aqui eu preferi trabalhar com conceito de class pelo motivo de não ter que instanciar varias vezes em memória os valores das credenciais do banco e assim deixamos global.


class DataBase {
  public client: MongoClient;
  constructor(
    public dbName: string,
    public url: string
  ) {
    this.dbName = dbName;
    this.url = url;
    this.client = {} as MongoClient;;
  }

  connect() {
    const client = new MongoClient();
    client.connectWithUri(this.url);
    this.client = client;
  }

Basicamente no código acima eu deixo exposto no método MongoClient e no construtor eu passo o que preciso popular que no caso vão ser o dbName e a url (connectionString)

Feito isso criamos um método chamado connect()que será responsável pela abertura da conexão do mongo (como o próprio nome sugere)

Por fim terminamos nossa classe passando um método para encontrar a database que vamos trabalhar:

  get findDatabase() {
    return this.client.database(this.dbName)
  }
}

Onde basicamente vai nos retornar o database que pedimos

E para finalizar vamos fazer nossa chamada de classe e expor ela como default para nossos arquivos externos conseguirem enxergar


const connectionDatabase = new DataBase(dbName, dbURI);
connectionDatabase.connect()

export default connectionDatabase;

Feito isso você já poderá se conectar ao Mongo sem problemas.

Models

Antes de criar nossos métodos vamos preparar nossa tipagem de dados, mas para a lib do Mongo precisamos tipar e passar o $oid e alguns dos métodos da controller.


export default interface User  {
    _id: {
        $oid: string;
      };
      name: string;
      middleName: string;
      profession: string;
}

Handle Error

A ideia do Handler vai ser de normalizar o padrão de mensagens de erro na nossa aplicação


import { MiddlewareFunc } from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

// Você já sabe como uma class funciona o/
export class ErrorHandler extends Error {
  status: number;
  constructor(msg: string, status: number) {
    super(msg); // Super é responsável por dizer que essa é uma classe pai no nível l da hierarquia 
    this.status = status;
  }
}

export const ErrorMiddleware: MiddlewareFunc = (next) =>
  async (data) => {
    try {
// Se deu bom usamos o next() pra passar a info 
      await next(data);
    } catch (err) {
// Se deu ruim passamos no request só  o que precisamos ver, mensagem e status code
      const error = err as ErrorHandler;
      data.response.status = error.status || 500;
      data.response.body = error.message;
    }
  };

Controllers

Nas controllers será onde colocaremos de fato a parte lógica da aplicação e aqui teremos arquivos para cada um dos métodos, achei melhor deixa-los separados para ficar fácil o manuseio, mas você pode deixar em um único arquivo os 4 métodos GET,POST,PUT e DELETE.

Vamos lá:

POST

Criaremos um arquivo chamado createUser.ts dentro da pasta Users na controller vou explicar dentro do arquivo o que cada coisa faz:


// esses imports são para tipagem dos métodos de contexto e de trafego de informação pelas rotas da lib ABC
import {
  HandlerFunc,
  Context,
} from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

// Importamos a nossa connectionDatabase para abriemos conexão com o banco de dados
import connectionDatabase from "../../database/connection.ts";

// Importamos o handler de erros que criamos para termos um padrão na saída deles
import { ErrorHandler } from "../../utils/handleError.ts";

// Abriremos nossa conexão passando a nossa collection previamente criada
const database = connectionDatabase.findDatabase;
const user = database.collection("users");

export const createUser: HandlerFunc = async (data: Context) => {
// Vamos adotar a boa prática de passar um try...catch
  try {

// Nesse primeiro if verificamos se nós estamos passando no Headers o content-type como application/json, se não estiver ele dispara um erro
    if (data.request.headers.get("content-type") !== "application/json") {
      throw new ErrorHandler("Body invalido", 422);
    }

// Para pegar o que passamos no corpo da aplicação, vamos escrever uma request usando await de tudo que temos no data.body (data é o parâmetro dessa nossa função)
    const body = await (data.body());

// Esse nosso if usamos o Object.keys() para verificar se foi passado objetos no corpo da requisição
    if (!Object.keys(body).length) {
      throw new ErrorHandler("O body não pode estar vazio!!", 400);
    }

// Feito essas validações vou desestruturar o que preciso inserir no banco
    const { name, profession, middleName } = body;
// Depois usamos o método insertOne({}) do MongoDB para persistir esses dados
    await user.insertOne({
      name,
      middleName,
      profession,
    });
// Terminamos aqui com o return passando uma mensagem que deu bom e o statusCode 200 o/
    return data.json('Usuário cadastrado com sucesso', 201);
  } catch (error) {

// Se der ruim nosso ErrorHandler será encarregado de nos avisar 
    throw new ErrorHandler(error.message, error.status || 500);
  }
};

GET

Criaremos um arquivo chamado getAllUsers.ts dentro da pasta Users na controller vou explicar dentro do arquivo o que cada coisa faz.

O GET é o mais simples, pois só usaremos o find() do mongo e retornaremos a lista de tudo que temos cadastrado


import {
    HandlerFunc,
    Context,
} from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

import connectionDatabase from "../../database/connection.ts";
import { ErrorHandler } from "../../utils/handleError.ts";

// Importamos a nossa tipagem de dados de usuário 
import Users from '../../model/users.ts'

const database = connectionDatabase.findDatabase;
const user = database.collection("users");

export const getAllUsers: HandlerFunc = async (data: Context) => {
    try {
// Verificamos se existe o user com o método find() do Mongo
        const existUser: Users[] = await user.find();
// Se existir retornamos com o map(), se não retornamos array vazio
        if (existUser) {
            const list = existUser.length
                ? existUser.map((item: any) => {
                    const { _id: { $oid }, name, middleName, profession } = item;

                    console.log('item :>> ', item);
                    return { id: $oid, name, middleName, profession };
                }) : [];

            return data.json(list, 200);
        }
    } catch (error) {
        throw new ErrorHandler(error.message, error.status || 500);
    }
};

GET ONE

Esse método será responsável por trazer apenas um registro que será passado por queryString


import {
  HandlerFunc,
  Context,
} from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

import connectionDatabase from "../../database/connection.ts";
import { ErrorHandler } from "../../utils/handleError.ts";

const database = connectionDatabase.findDatabase;
const user = database.collection("users");

export const getUser: HandlerFunc = async (data: Context) => {
  try {

// Vamos capturar o que será passado como parâmetro e usando o as do typescript para tipar o valor como string
    const { id } = data.params as { id: string };

// Usaremos o findOne() do mongo pra trazer uma bolleana de existUser ou não o valor
    const existUser = await user.findOne({ _id: { "$oid": id } });

    if (existUser) {

// Existindo, vamos desestruturar o resultado e retornar no data.json() junto com o status code
      const { _id: { $oid }, name, middleName, profession } = existUser;
      return data.json({ id: $oid, name, middleName, profession }, 200);
    }
// Caso não exista, receberemos a mensagem abaixo com o status 404
    throw new ErrorHandler("Usuário não encontrado", 404);
  } catch (error) {
    throw new ErrorHandler(error.message, error.status || 500);
  }
};

PUT (UPDATE)

Criaremos um arquivo chamado updateUser.ts dentro da pasta Users na controller vou explicar dentro do arquivo o que cada coisa faz.

Esse método tem mais validações por questão de segurança , se estaremos ou não passando as informações correta ou não, vamos analizar:


import {
  HandlerFunc,
  Context,
} from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

import connectionDatabase from "../../database/connection.ts";
import { ErrorHandler } from "../../utils/handleError.ts";

const database = connectionDatabase.findDatabase;
const user = database.collection("users");

export const updateUser: HandlerFunc = async (data: Context) => {
  try {
    const { id } = data.params as { id: string };

    if (data.request.headers.get("content-type") !== "application/json") {
      throw new ErrorHandler("Invalid body", 422);
    }

// Capturamos o valor do corpo da aplicação e tipamos os dados passando o sinal de ? para sinalizar que é um campo opcional
    const body = await (data.body()) as {
      name?: string;
      middleName?: string;
      profession?: string;
    };

    if (!Object.keys(body).length) {
      throw new ErrorHandler("O body não pode estar vazio!", 400);
    }

// Aqui vamos usar o findOne() novamente e verificar se existe
    const existUser = await user.findOne({ _id: { "$oid": id } });

    if (existUser) {
      const { matchedCount } = await user.updateOne(
        { _id: { "$oid": id } },
        { $set: body },
      );

// Esse matchedCount que recebemos no resultado do findOne() é o responsável por nos dar a informação de se foi encontrado ou não no caso será 1 dado e finalizamos com return data.string()
      if (matchedCount) {
        return data.string("O usuário foi atualizado com sucesso!", 204);
      }

// Caso não der certo mandaremos essa mensagem para a requisição 
      return data.string("Não foi possível atualizar esse usuário");
    }
    throw new ErrorHandler("Usuário não encontrado", 404);
  } catch (error) {
    throw new ErrorHandler(error.message, error.status || 500);
  }
};

DELETE

Criaremos um arquivo chamado deleteUser.ts dentro da pasta Users na controller vou explicar dentro do arquivo o que cada coisa faz.

O nosso delete é bem simples com a carga das coisas que aprendemos nos anteriores, veja:


import {
  HandlerFunc,
  Context,
} from "https://deno.land/x/abc@v1.0.0-rc2/mod.ts";

import connectionDatabase from "../../database/connection.ts";
import { ErrorHandler } from "../../utils/handleError.ts";

const database = connectionDatabase.findDatabase;
const user = database.collection("users");

export const deleteUser: HandlerFunc = async (data: Context) => {
  try {
    const { id } = data.params as { id: string };

    const existUser = await user.findOne({ _id: { "$oid": id } });

    if (existUser) {

// Usaremos o deleteOne() do banco para realizar a operação e ele vai retornar o valor de dado deletado, no caso 1
      const deleteCount = await user.deleteOne({ _id: { "$oid": id } });
      if (deleteCount) {

// Após receber o valor 1 vamos responder a requisição com a mensagem  abaixo
        return data.string("Usuário foi deletado!", 204);
      }
      throw new ErrorHandler("Não foi possivel excuir esse usuário", 400);
    }

    throw new ErrorHandler("Usuário não encontrado", 404);
  } catch (error) {
    throw new ErrorHandler(error.message, error.status || 500);
  }
};

Por fim vamos padronizar as exportações criando um arquivo index.ts dentro da pasta Users com os seguinte código:


export { getAllUsers } from './getAllUsers.ts';
export { createUser } from './createUser.ts';
export { getUser } from './getOneUser.ts';
export { updateUser } from './updateUser.ts';
export { deleteUser } from './deleteUser.ts';

.ENV

O .ENV é onde vamos colocar as variáveis globais da aplicação
Crie um arquivo chamado .env na raiz do projeto (mesmo nivel do arquivo server.ts) com a seguinte informação:


DATABASE_NAME=deno
DATABASE_HOST=<_sua_url_do_mongo_>

Foi muita coisa agora, mas agora você sabe criar uma API para brincar nos seus projetos ou até mesmo aplicar com NodeJS

Feito tudo isso podemos executar nosso projeto com o comando

deno run --allow-write --allow-read --allow-plugin --allow-net --allow-env --unstable ./server.ts

O código dessa API se encontra nesse Repositório

Por enquanto é isso e nos vemos em breve, dúvidas ou sugestão deixem nos comentários ou nos procure nas redes Sociais!

Acompanhe nossos canais de conteúdo:

Implementando JWT com Deno e ABC

Leonardo Oliveira Balsalobre — Thu, 11 Jun 2020 14:39:26 +0000

Conforme temos visto nos ultimo meses, o novo runtime feito por Ryan Dahl (criador do Node) vem tomando espaço no cronograma de estudos de diversos desenvolvedores e entusiastas.

Mas o que é o Deno?

Deno visa fornecer um ambiente de script produtivo e seguro para o programador moderno. Ele é construído sobre V8, Rust e TypeScript.

A principal característica que chamou atenção no novo runtime, foi a forma com qual foi construído, sempre buscando tornar o acesso e o trafego dos dados mais seguro.

Por exemplo:

Em Node, para iniciarmos um servidor executamos "npm start" ou "npm run dev", de uma forma simples e imediata o seu servidor ja está rodando.

Já no Deno, é necessário dar permissão para que ele acesse sua internet(--allow-net), escrita(--allow-write), leitura(--alow-read), entre outros(--allow-all). E para aprimorar ainda mais nossa segurança iremos utilizar o famoso JWT.

Bora para o que interessa!

Nesse projeto usaremos as seguintes bibliotecas:

Framework ABC: https://deno.land/x/abc
Bcrypt: https://deno.land/x/bcrypt
Djwt: https://deno.land/x/djwt
Mongo: https://deno.land/x/mongo

Primeiramente vocês vão precisar baixar as dependências....

Só que não! O Deno importa suas dependências diretamente da sua raiz e assim não existe nenhum node_modules com alguns milhares de megabytes.

Ao iniciarmos a construção da nossa API, a primeira coisa que vamos fazer é criar um endpoint de usuário e como o Deno ja suporta Typescript por padrão então iremos utiliza-lo ;D

Primeiramente importamos HandlerFunc e Context que são premissas para criarmos as funções utilizando o framework ABC (também temos o Oak que tem uma similaridade com Koa)
Após importarmos note que estamos importando diretamente do deno.land, isso significa que ao iniciarmos o servidor o Deno irá baixar as dependências e armazená-las em um cache, mas isso é assunto para um outro artigo.

Também importaremos o bcrypt que é uma biblioteca para gerar hash da senha do usuário aumentando ainda mais a segurança da nossa API.
Em seguida iremos criar nosso token.ts que é a configuração da autenticação do JWT que será usada no projeto. Note que na expiração colocamos a data atual mais 60 * 60000 que significa 1 hora, onde 60000 é 1 minuto.

Após nosso token estar totalmente configurado iremos fazer uma controller que se chamará authController.ts, ela será a responsável por interceptar todas as requisições da nossa API, sendo usada como um middleware. Outro ponto que gostaria de comentar é que ao construir esse projeto procurei inúmeras formas de validar quais rotas teriam acesso sem que o interceptador de token entrasse em vigor. A única forma com qual consegui foi buscando dentro do contexto da requisição qual é o path da rota, sendo assim fiz um if para que caso a rota não fosse a que eu queria, o interceptador seria executado, do contrario, a rota estaria livre de token, que é o cenário que queremos no caso de login.

Por fim iremos no nosso server.ts fazer com que nosso app use o authController como middleware.

Considerações finais
Para quem não tem conhecimento em API's ou até mesmo em Deno básico, talvez esse artigo não seja tão útil, mas a intenção foi passar o conhecimento de como utilizei o ABC para fazer uma autenticação JWT, até o momento em que fiz esse mini-projeto não havia encontrado em lugar algum da internet uma autenticação JWT que não usasse o Oak.

Para fins de duvidas, estou disponibilizando meu repositório que é exatamente esse da imagem onde tenho um Crud completo de usuário com bcrypt e JWT implementados.

Link do repositório: https://github.com/oliveirabalsa/deno-demo

Por enquanto é isso e nos vemos em breve, dúvidas ou sugestão deixem nos comentários ou nos procure nas redes Sociais!

Acompanhe nossos canais de conteúdo:

O que você precisa saber sobre o Deno!?

Telles (@UnicornCoder) — Mon, 25 May 2020 05:20:02 +0000

Bom, como já sabemos e é um assunto muito falado ultimamente, recentemente fiz uma live falando do Deno e ele veio ai com a proposta de ser uma nova Runtime de JavaScript assim como o Node, mas com o foco em segurança e performance.

Vamos falar aqui sobre algumas particularidades do Deno e umas perguntas que surgiram como o lançamento da v1.0.

Uso do ES6

O Deno utiliza o ES6 como padrão no desenvolvimento, ou seja não vamos precisar de um babel da vida para transpilar um Common JS assim como faziamos no NodeJS.

TypeScript

Como muitos já comentaram o TS á algo nativo no Deno e ainda temos uns problemas de performance por estar usando o transpilador da Microsoft, mas isso ja esta no radar de melhorias com a possível solução de reescrita do transpiler em rust (linguagem padrão do Deno).

Gerenciamento de Pacotes (Módulos)

Como vocês habitualmente sabem o node tem o NPM para gerenciar seus pacotes e assim ele cria uma pasta no projeto chamada node_modules contendo os pacotes instalados(baixando-os).

No Deno temos duas categorias de pacotes, os nativos chamados de standards ou str e os de terceiros que são chamados de x, e podem ser encontrados com facilidade no site do Deno.

No Deno isso funciona de uma maneira diferente, pois o Deno baixa o que você precisa em cache em uma única pasta no seu SO.
Mas Diego, que pasta é essa? Pra onde vai esses arquivos? Posso acesssar eles?
-Sim, voce pode acessar esses arquivos e para que voce saiba onde eles estao é somente usar o comando:

$ deno info

Com esse comando ele vai trazer pra voce as seguintes informações:

Diretório do Deno
Diretório dos seus módulos
Cache do compilador TypeScript

Como saber os pacotes instalados na aplicação

Uma coisa que fiquei preocupado era se tinha a existência de um package.json assim como existe no node para sabermos o que tem instalando na nossa aplicação.
E sim, existe a possibilidade de ter um arquivo contendo esses módulos baixados sendo listados.

Para isso precisamos criar um arquivo import_map.json e dentro dele ter a seguinte estrutura:


// import_map.json

{
   "imports": {

   }
}

Mas além disso precisamos passar uma flag no nosso CLI
--importmap=import_map.json para dizer ao Deno que queremos escrever nesse arquivo como o nome dos pacotes, assim:

$ deno run --allow-net --importmap=import_map.json --unstable <nome do arquivo_raiz>.ts, mas na documentação mesmo diz que essa funcionalidade pode não funcionar agora por estar unstable.

Arquitetura do Deno (por baixo dos panos)

O Deno utiliza o Tokyo como Run-time para realização dos loops assíncronos de eventos na aplicação, ele é escrito em Rust.

Temos a camada de Recursos com algumas libs stdio, TCP Socket, child process, entre outros recursos...(Falaremos mais disso em outro momento).

E temos também a camada de comunicação do JS com a V8 e com o C++ sendo diretamente ligada com um modulo isolado de rusty que é o Deno.

Por fim, uma demo

API usando o Deno que criei recentemente em TS para testar o poder da Run-time, ela está salvando os dados em um banco MongoDB e usando a lib ABC pra fazer o serviço que o Express faz no Node.

Por enquanto é isso e nos vemos em breve, dúvidas ou sugestão deixem nos comentários ou nos procure nas redes Sociais!

Acompanhe nossos canais de conteúdo:

Bem vindo ao Deno

Jonatas Santos — Thu, 21 May 2020 22:30:32 +0000

Olá meus queridos, sejam todos bem vindos, iremos falar sobre o novo framework Deno.

O que é o Deno?
Deno é um ambiente de execução para JavaScript e TypeScript baseado no V8, engine de JavaScript do Google Chrome e na linguagem de programação Rust. Foi criado por Ryan Dahl, criador original do Node.js, e é focado em segurança e produtividade.

Principais características

Seguro por padrão. Sem acesso a arquivos, redes ou ambientes (a menos que seja explicitamente ativado).
Possui um runtime TypeScrip Os scripts podem ser agrupados em um único arquivo JavaScript.
Construído em Rust (o núcleo do Deno foi escrito em Rust, Node e C++), Tokio (loop de eventos) e V8 (runtime JavaScript)

Deno é mais seguro?
Qualquer código no Node tem o poder de acessar as suas informações como sua rede,HD entre outros. Por outro lado, no Deno o seu código é executado em uma sandbox(semelhante a uma maquina virtual), focado em segurança por padrão.
Ou seja, se você não der permissão, um código malicioso não poderá acessar suas informações. Isso se assemelha ao JavaScript nos navegadores, que só pode acessar câmera se o usuário der permissão.

TypeScript Integrado
O Deno não interpreta apenas JavaScript. Ele também interpreta TypeScript sem que você precise instalar nem configurar nada.

Essa decisão foi baseada no crescimento do uso do TypeScript em grandes projetos que precisam lidar com complexas lógicas de negócio.

Promises em todo lugar
O JavaScript é famoso por sua natureza assíncrona. Porém, o Node foi criado antes do JavaScript possuir coisas como Promises e Async/Await.
Como resultado da evolução do JavaScript em união da linguagem Rust, o Deno tem um moderno sistema baseado em Promises. Isso nos permite trabalhar mais facilmente com código assíncrono, nesse caso todas ações assíncronas retornaram uma Promise.

Preparando o ambiente Windows
Agora vamos a instalação que é bem simples, acesse a Documentação.
Como estou utilizando o Windows, vou instalar via Powershell:

iwr https://deno.land/x/install/install.ps1 -useb | iex

Subindo o Server
No site oficial temos um pequeno trecho de código em TypeScript que nos mostra como é muito simples para subir um pequeno servidor.

// ES Modules
import { serve } from "https://deno.land/std@0.50.0/http/server.ts";

//Cria o Server
const server = serve({ port: 8000 });

console.log("http://localhost:8000/");

//Async iterador para atender solicitações do servidor 
for await (const req of server) {
  req.respond({ body: "<h1>Hello World\n</h1>" });
}

Para executar essa aplicação usamos o comando em nosso terminal
➜ deno run server.ts

Opsss Deu ruim!!!

Isto ocorre porque como comentei acima as medidas de segurança do Deno interferem na execução do nosso arquivo server.ts com a seguinte mensagem:

➜  Deno deno run server.ts 
error: Uncaught PermissionDenied: network access to "0.0.0.0:8000", 
run again with the --allow-net flag
    at unwrapResponse ($deno$/ops/dispatch_json.ts:43:11)
    at Object.sendSync ($deno$/ops/dispatch_json.ts:72:10)
    at Object.listen ($deno$/ops/net.ts:51:10)
    at listen ($deno$/net.ts:152:22)
    at serve (https://deno.land/std@0.50.0/http/server.ts:261:20)
    at file:///mnt/e/projects/Deno/server.ts:3:16
➜  Deno

Isso acontece porque por regra de segurança ele nos "força" a conceder o acesso a rede, impedindo que isso aconteça automaticamente como no Node.

Para que esse acesso possa acontecer precisamos incluir a tag --allow-net no nosso comando, passando a ser executado dessa maneira:
➜ deno run --allow-net server.ts
Se tudo ocorreu corretamente ele vai retornar a seguinte mensagem
Compile file:///mnt/e/projects/Deno/server.ts http://localhost:8000/

Bom este foi um tutorial bem básico do novo framework Deno, para mais informações olhem a Documentação e faça parte do nosso grupo para mais novidades.

Acompanhe nossos canais de conteúdo:

Deno x Node - O que é e algumas diferenças importantes

Telles (@UnicornCoder) — Thu, 21 May 2020 09:24:04 +0000

O que estamos vendo por ai é que o Deno vem ai pra substituir o Node.
Mas aqui vamos ver o real motivo do Deno ter nascido.

Vamos começar com a história do Deno.

Surgimento do Deno

Já sendo tratado por alguns como a próxima grande novidade e que veio para substituir o NodeJS, ambos têm a mesma origem: Ryan Dahl.

Apesar do trocadilho com os nomes Node e Deno e ter como integrante do time Ryan Dahl que é o criador e trabalhou no projeto Node desde 2009, mas se afastou do projeto Node alguns anos depois.
Em 2018, ele deu a palestra na JS Conf EU sobre 10 Coisas que Eu Lamento Sobre o Node, onde ele também anunciou o Deno - um novo JavaScript & TypeScript Runtime.

Recentemente o Deno chegou na sua versão 1.0 e o Node por outro lado já é mais antigo, mas essencialmente ambos tem o mesmo objetivo.

Eles são JavaScript Runtimes, ou seja, podemos usar JS fora do navegador, por exemplo, para servidores da web.
Mas como serão as coisas entre Deno e Node em alguns anos, por conta do Deno ser muito novo quase ninguém sabe.

O que temos por baixo dos panos do Deno e do Node?

Como sabemos o Node é baseado em C++ e usa o mecanismo V8 para executar o código JavaScript.
O mecanismo V8 foi desenvolvido originalmente para o Google Chrome para executar o JavaScript no navegador com mais velocidade.

Por esse motivo, até a nova versão do Microsoft Edge é baseada no V8.

O Deno também conta com o mecanismo V8, mas, em vez do uso do C++, ele também se baseia no Rust - uma linguagem de programação que deve oferecer desempenho tão bom como o C++, mas enfatiza a segurança: erros de acesso à memória ou estouros de buffer devem ser evitado.

A segurança vem sendo uma crítica comum ao Node, pois quando um aplicativo em node está em execução, ele pode acessar facilmente o sistema de arquivos ou a rede, por exemplo.

O Deno quer evitar esse tipo de acesso "automático" exigindo que a pessoa que executa a aplicação com o Deno permita primeiro o que ele quer fazer.

Para exemplificar isso melhor vamos para um exemplo de como isso acontece:

No site Oficial do Deno temos esse pequeno trecho de código em TypeScript que nos dá uma noção de como isso acontece

import { serve } from "https://deno.land/std@0.50.0/http/server.ts";
const s = serve({ port: 8000 });
for await (const req of s) { 
  req.respond ({body: “Hello World \ n”}); 
}

Para executar essa aplicação usamos o comando em nosso terminal
>_ deno run server.ts

Porém as medidas de segurança do Deno interferem na execução do nosso server.ts trazendo a seguinte mensagem:

Isso acontece porque ele nos "força" a conceder o acesso a rede, impedindo que isso aconteça automaticamente como no Node.

Para que esse acesso possa acontecer precisamos incluir a tag --allow-net no nosso comando, passando a ser executado dessa maneira:

>_ deno run --allow-net server.ts

Agora, nosso servidor web está sendo executado, mas dessa forma apenas demos aprovação ao acesso de rede, então nossa aplicação ainda não pode acessar o sistema de arquivos assim, para isso teríamos que permitir manualmente primeiro.

Mas e como vão ser as importações?

Mais uma coisa referente a segurança da nossa aplicação é o NPM.
O uso do NPM geralmente resulta em uma pasta chamada de node_modules, além disso também tem o problema com o node e a segurança: se usarmos o NPM para instalar um pacote para a aplicação em Node, ele pode teoricamente fazer outra coisa às escondidas.

Já aconteceu, houve um escândalo com os pacotes NPM, que, por exemplo, espionaram dados do usuário.

O Deno não depende totalmente do NPM, em vez disso, importamos nossas bibliotecas por meio da URL, conforme mostrado no exemplo de código abaixo:


import { serve } from "https://deno.land/std@0.50.0/http/server.ts";

Mas pra onde vai isso se não usamos uma pasta de módulos assim como o Node?

Resposta: A biblioteca que queremos usar é baixada na primeira vez em que a aplicação é executada e logo em seguida, armazenada em cache:

O object window - também fora do navegador

O object window é o objeto pai no navegador, e nele temos algumas das funções mais importantes do JS.

Uma delas é, por exemplo é o fetch .

Infelizmente, não temos uma alternativa nativa para bibliotecas como o fetch no Node e é preciso encontrar uma solução com as bibliotecas externas como a do Axios, mas não no Deno.
Como no Deno, o object window está disponível, como você pode ver na documentação.

E onde window está, também podemos usar a busca, como faria em um navegador.
Vamos tentar isso e você verá que pode executar o seguinte código no navegador, mas também em uma aplicação com Deno:

fetch("https://pokeapi.co/api/v2/pokemon/1/") 
  .then(( response ) => response.json ()) 
  .then(( json ) => console.log ( json ));

Dentre as principais novidades que o Deno trás, são destacadas:

Suporte a TypeScript sem necessidade de nenhuma outra solução ou ferramenta adicional.
Melhor integração com Rust, tornando mais fácil o mapeamento de Futures de APIs Rust em Promessas do JavaScript.

Vale lembrar que o Deno é um projeto totalmente novo e não um fork do Node.

Recentemente foi lançado um artigo no site do Deno sobre o fechamento da versão 1.0 onde eles citam algumas limitações que são:

Uma queda na performance de processamento de requisições HTTP, quando comparada com a performance de uma aplicação em Node.
Um gargalo na compilação do código, uma vez que o Deno utiliza o compilador TypeScript da Microsoft para gerar o código JavaScript.

Os autores acreditam que o compilador pode ser reescrito em Rust para resolver essa questão e estão a procura de pessoas interessadas em contribuir com isso.

Uma interface ainda em desenvolvimento e instável para a criação de extensões customizadas do runtime Deno.

Acompanhe nossos canais de conteúdo: