Creating URL Shortener with Node.js and Couchbase using N1QL

Com o boom do Twitter, das mensagens de texto SMS e de outras formas de interação com mensagens curtas, houve um boom nos serviços de encurtamento de URL. Por exemplo, você pode usar o TinyURL, o Bitly, o Owly e muitos outros. O objetivo aqui é pegar URLs muito longos e torná-los significativamente mais curtos para distribuição em uma mensagem.

Mas como funcionam esses serviços de encurtamento de URL?

Veremos como criar nosso próprio encurtador de URL usando Node.js com o Express Framework e o Couchbase Server com N1QL. Em nosso exemplo, os URLs curtos serão gerados usando o Node.js e serão armazenados e acessados usando o Couchbase.

Os requisitos

Não há muitos requisitos para tornar esse projeto possível. No mínimo, você precisará do seguinte para ser bem-sucedido:

Servidor Couchbase 4.1+
Node.js 4.0+

Precisamos usar uma versão do Couchbase Server que ofereça suporte a consultas N1QL. A versão do Node.js é menos rigorosa, mas precisaremos dela para atender ao nosso aplicativo e obter dependências usando o Node Package Manager (NPM).

Preparando o Couchbase e entendendo o formato dos dados

Antes de começarmos a desenvolver nosso aplicativo Node.js, precisamos entender o plano de dados e configurar o Couchbase Server para permitir consultas N1QL.

No Couchbase, o objetivo é armazenar nossos dados no seguinte formato:

{
    "id": "5Qp8oLmWX",
    "longUrl": "https://www.thepolyglotdeveloper.com/2016/08/using-couchbase-server-golang-web-application/",
    "shortUrl": "http://localhost:3000/5Qp8oLmWX"
}

{

"id": "5Qp8oLmWX",

"longUrl": "https://www.thepolyglotdeveloper.com/2016/08/using-couchbase-server-golang-web-application/",

"shortUrl": "http://localhost:3000/5Qp8oLmWX"

}

Passaremos ao aplicativo um URL longo e geraremos um hash curto exclusivo com base em uma parte dos dados. Esse hash será usado na construção do URL curto, que também será armazenado no documento do Couchbase. O ID do próprio documento também será o do valor do hash.

Agora precisamos criar um bucket do Couchbase Server para armazenar os dados do nosso aplicativo. Esse bucket pode ser criado por meio do painel de administração do Couchbase Server. Vamos chamar esse bucket de exemplo.

Ao consultar os dados, nem sempre faremos pesquisas com base no valor de id. Isso significa que precisaremos criar índices nos valores dos documentos para permitir consultas N1QL. Para manter as coisas simples, crie um índice primário simples como o seguinte:

CREATE PRIMARY INDEX ON `example` USING GSI;

1	CRIAR PRIMÁRIO ÍNDICE ON `exemplo` USO GSI;

Essa consulta pode ser executada usando o Couchbase Server Query Workbench (Enterprise Edition) ou o Couchbase Shell, conhecido como CBQ. O índice não será o mais rápido porque é muito geral, mas atenderá às necessidades do nosso aplicativo muito simples.

Desenvolvimento do aplicativo encurtador de URL do Node.js com a estrutura Express

Com o banco de dados configurado corretamente, podemos nos preocupar com o código por trás do aplicativo. Esse aplicativo dependerá muito do Express Framework e do Couchbase, mas também de uma biblioteca de hashing conhecida como Hashids.

Criando o projeto com as dependências

Vamos criar um novo projeto Node.js no prompt de comando (Windows) ou no Terminal (Mac e Linux):

npm init --y

1	npm inicial --y

O comando acima criará um arquivo package.json onde quer que você esteja navegando atualmente pela linha de comando. Portanto, esperamos que você esteja em um diretório novo.

Agora precisamos instalar as dependências do projeto. Execute o seguinte na linha de comando:

npm install couchbase body-parser express hashids --save

1	npm instalar couchbase corpo-analisador expresso hashids --salvar

Neste ponto, podemos nos preocupar com o desenvolvimento do JavaScript.

Bootstrapping do aplicativo Node.js

Para manter este projeto simples e fácil de entender, manteremos toda a lógica do aplicativo em um único arquivo. Em um aplicativo de produção, você provavelmente desejará dividi-lo para fins de limpeza e manutenção, mas para este exemplo não haverá problema.

Crie um arquivo chamado app.js na raiz do diretório do seu projeto. Nesse arquivo, a primeira coisa que faremos é importar as dependências instaladas da seguinte forma:

var Couchbase = require("couchbase");
var Express = require("express");
var BodyParser = require("body-parser");
var Hashids = require("hashids");

var Couchbase = exigir("couchbase");

var Expresso = exigir("expresso");

var Analisador de corpo = exigir("body-parser");

var Hashids = exigir("hashids");

Porque eu ainda não expliquei o analisador de corpo vou explicá-la agora. Essa dependência nos permite fazer solicitações que contêm um corpo. Por exemplo, ao fazer solicitações POST ou PUT, é comum incluir um corpo JSON em vez de parâmetros de URL ou parâmetros de consulta.

Com as dependências importadas, precisamos inicializar o Express Framework e o mecanismo N1QL do Couchbase:

var app = Express();
var N1qlQuery = Couchbase.N1qlQuery;

1 2	var aplicativo = Expresso(); var N1qlQuery = Couchbase.N1qlQuery;

Embora tenhamos importado o analisador de corpo mas ainda não o inicializamos. Queremos poder aceitar valores codificados em JSON e URL, portanto, precisamos configurar a dependência da seguinte forma:

app.use(BodyParser.json());
app.use(BodyParser.urlencoded({ extended: true }));

1 2	aplicativo.uso(Analisador de corpo.json()); aplicativo.uso(Analisador de corpo.codificado por url({ estendido: verdadeiro }));

Neste ponto, todas as nossas dependências estão inicializadas. Seria uma boa ideia agora estabelecer uma conexão com o cluster do Couchbase Server e o bucket do aplicativo. Isso pode ser feito com a seguinte linha:

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");

1	var balde = (novo Couchbase.Aglomerado("couchbase://localhost")).openBucket("exemplo");

Por fim, vamos começar a servir nosso aplicativo Node.js com o seguinte:

var server = app.listen(3000, function() {
    console.log("Listening on port %s...", server.address().port);
});

var servidor = aplicativo.ouvir(3000, função() {

console.registro("Escutando na porta %s...", servidor.endereço().porto);

});

Você provavelmente está percebendo que não adicionamos nenhuma lógica. Você está correto ao perceber isso, pois, até agora, só fizemos o bootstrapping do nosso aplicativo.

Criação da lógica de aplicativo do encurtador de URL

O que queremos fazer agora é criar alguns endpoints de API RESTful. Vamos criar os seguintes endpoints:

/
/expand
/create

/expandir

/criar

O raiz será usado para navegar para um URL longo que está mascarado por trás de um URL curto. O /expandir receberá um URL curto e revelará o URL longo sem navegar até ele, e o ponto de extremidade /criar pegará um URL longo e criará um URL curto no banco de dados.

Começando com o /criar e provavelmente o ponto final mais complicado, temos o seguinte:

app.post("/create", function(req, res) {
    if(!req.body.longUrl) {
        return res.status(400).send({"status": "error", "message": "A long URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE longUrl = $1"), [req.body.longUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        if(result.length == 0) {
            var hashids = new Hashids();
            var response = {
                id: hashids.encode((new Date).getTime()),
                longUrl: req.body.longUrl
            }
            response.shortUrl = "http://localhost:3000/" + response.id;
            bucket.insert(response.id, response, function(error, result) {
                if(error) {
                    return res.status(400).send(error);
                }
                res.send(response);
            });
        } else {
            res.send(result[0]);
        }
    });
});

aplicativo.postagem("/create", função(req, res) {

se(!req.corpo.longUrl) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um URL longo"});

}

balde.consulta(N1qlQuery.fromString("SELECT `" + balde._nome + "`.* FROM `" + balde._nome + "` WHERE longUrl = $1"), [req.corpo.longUrl], função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

se(resultado.comprimento == 0) {

var hashids = novo Hashids();

var resposta = {

id: hashids.codificar((novo Data).getTime()),

longUrl: req.corpo.longUrl

}

resposta.shortUrl = "http://localhost:3000/" + resposta.id;

balde.inserir(resposta.id, resposta, função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(resposta);

});

} mais {

res.enviar(resultado[0]);

}

});

Esse endpoint é uma solicitação POST que espera um corpo JSON. Se a solicitação longUrl A propriedade JSON não existe, um erro será retornado ao usuário.

Antes de realmente criarmos o URL curto, queremos ter certeza de que ainda não foi criado um. Fazemos isso porque queremos um URL curto para cada URL longo. Podemos fazer isso criando uma consulta N1QL parametrizada com base no parâmetro longUrl propriedade. Se a resposta contiver um documento, nós o retornaremos porque o documento já existe. Se a resposta não tiver um documento, precisaremos criar um.

Usando o hashids dependência, podemos criar um hash com base no registro de data e hora e usá-lo como nosso ID e nosso URL curto. Depois de inserir esse novo documento, podemos devolvê-lo ao usuário.

Agora vamos dar uma olhada em como expandir esses URLs curtos.

app.get("/expand", function(req, res) {
    if(!req.query.shortUrl) {
        return res.status(400).send({"status": "error", "message": "A short URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE shortUrl = $1"), [req.query.shortUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result.length &gt; 0 ? result[0] : {});
    });
});

aplicativo.obter("/expandir", função(req, res) {

se(!req.consulta.shortUrl) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um URL curto"});

}

balde.consulta(N1qlQuery.fromString("SELECT `" + balde._nome + "`.* FROM `" + balde._nome + "` WHERE shortUrl = $1"), [req.consulta.shortUrl], função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(resultado.comprimento > 0 ? resultado[0] : {});

});

O código acima usa um conceito semelhante ao do /criar ponto final. Tomamos um shortUrl e consultá-lo usando o N1QL. Se for encontrado, podemos retornar o URL longo com a resposta.

Finalmente, podemos nos preocupar com a navegação.

app.get("/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An id is required"});
    }
    bucket.get(req.params.id, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.redirect(result.value.longUrl);
    })
});

aplicativo.obter("/:id", função(req, res) {

se(!req.parâmetros.id) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessária uma identificação"});

}

balde.obter(req.parâmetros.id, função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.redirecionar(resultado.valor.longUrl);

})

});

Lembre-se, nossos URLs curtos estão no formato http://localhost:3000/5Qp8oLmWX que é o mesmo local do nosso serviço de API. O que isso significa é que 5Qp8oLmWX é apenas um parâmetro de URL para nosso raiz ponto final.

Com o id, podemos fazer uma pesquisa de documento com base no valor da chave. Se for bem-sucedida, teremos o documento que está armazenado no momento.

O código-fonte completo do aplicativo

Caso você queira ver o código-fonte completo do aplicativo que acabamos de criar, ele pode ser encontrado abaixo.

var Couchbase = require("couchbase");
var Express = require("express");
var BodyParser = require("body-parser");
var Hashids = require("hashids");

var app = Express();
var N1qlQuery = Couchbase.N1qlQuery;

app.use(BodyParser.json());
app.use(BodyParser.urlencoded({ extended: true }));

var bucket = (new Couchbase.Cluster("couchbase://localhost")).openBucket("example");

app.get("/expand", function(req, res) {
    if(!req.query.shortUrl) {
        return res.status(400).send({"status": "error", "message": "A short URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE shortUrl = $1"), [req.query.shortUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result.length &gt; 0 ? result[0] : {});
    });
});

app.post("/create", function(req, res) {
    if(!req.body.longUrl) {
        return res.status(400).send({"status": "error", "message": "A long URL is required"});
    }
    bucket.query(N1qlQuery.fromString("SELECT `" + bucket._name + "`.* FROM `" + bucket._name + "` WHERE longUrl = $1"), [req.body.longUrl], function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        if(result.length == 0) {
            var hashids = new Hashids();
            var response = {
                id: hashids.encode((new Date).getTime()),
                longUrl: req.body.longUrl
            }
            response.shortUrl = "http://localhost:3000/" + response.id;
            bucket.insert(response.id, response, function(error, result) {
                if(error) {
                    return res.status(400).send(error);
                }
                res.send(response);
            });
        } else {
            res.send(result[0]);
        }
    });
});

app.get("/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An id is required"});
    }
    bucket.get(req.params.id, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.redirect(result.value.longUrl);
    })
});

var server = app.listen(3000, function() {
    console.log("Listening on port %s...", server.address().port);
});

var Couchbase = exigir("couchbase");

var Expresso = exigir("expresso");

var Analisador de corpo = exigir("body-parser");

var Hashids = exigir("hashids");

var aplicativo = Expresso();

var N1qlQuery = Couchbase.N1qlQuery;

aplicativo.uso(Analisador de corpo.json());

aplicativo.uso(Analisador de corpo.codificado por url({ estendido: verdadeiro }));

var balde = (novo Couchbase.Aglomerado("couchbase://localhost")).openBucket("exemplo");

aplicativo.obter("/expandir", função(req, res) {

se(!req.consulta.shortUrl) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um URL curto"});

}

balde.consulta(N1qlQuery.fromString("SELECT `" + balde._nome + "`.* FROM `" + balde._nome + "` WHERE shortUrl = $1"), [req.consulta.shortUrl], função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(resultado.comprimento > 0 ? resultado[0] : {});

});

aplicativo.postagem("/create", função(req, res) {

se(!req.corpo.longUrl) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessário um URL longo"});

}

balde.consulta(N1qlQuery.fromString("SELECT `" + balde._nome + "`.* FROM `" + balde._nome + "` WHERE longUrl = $1"), [req.corpo.longUrl], função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

se(resultado.comprimento == 0) {

var hashids = novo Hashids();

var resposta = {

id: hashids.codificar((novo Data).getTime()),

longUrl: req.corpo.longUrl

}

resposta.shortUrl = "http://localhost:3000/" + resposta.id;

balde.inserir(resposta.id, resposta, função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.enviar(resposta);

});

} mais {

res.enviar(resultado[0]);

}

});

aplicativo.obter("/:id", função(req, res) {

se(!req.parâmetros.id) {

retorno res.status(400).enviar({"status": "error" (erro), "mensagem": "É necessária uma identificação"});

}

balde.obter(req.parâmetros.id, função(erro, resultado) {

se(erro) {

retorno res.status(400).enviar(erro);

}

res.redirecionar(resultado.valor.longUrl);

})

});

var servidor = aplicativo.ouvir(3000, função() {

console.registro("Escutando na porta %s...", servidor.endereço().porto);

});

Provavelmente, há muitas otimizações que podem ser feitas, mas nos preocupamos mais com a lógica para fazer deste um projeto bem-sucedido.

Conclusão

Você acabou de ver como criar um encurtador de URL muito básico usando o Node.js para a lógica do aplicativo, o Couchbase Server como o banco de dados NoSQL e o N1QL como a tecnologia de consulta.

Se você quiser levar isso para o próximo nível, poderá acompanhar as informações analíticas. Por exemplo, se alguém navegar até a página raiz aumentar um contador ou armazenar o agente do navegador. Coisas simples para adicionar um fator interessante ao aplicativo encurtador de URL.

Nic Raboy, defensor dos desenvolvedores, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Criar um encurtador de URL com Node.js e Couchbase usando N1QL

Os requisitos

Preparando o Couchbase e entendendo o formato dos dados

Desenvolvimento do aplicativo encurtador de URL do Node.js com a estrutura Express

Criando o projeto com as dependências

Bootstrapping do aplicativo Node.js

Criação da lógica de aplicativo do encurtador de URL

O código-fonte completo do aplicativo

Conclusão

Autor

Postado por Nic Raboy, defensor dos desenvolvedores, Couchbase

Deixar uma resposta Cancelar resposta