URL Shortener using Ottoman ODM with Node.js & Couchbase

Não faz muito tempo, escrevi sobre Criação de um encurtador de URL com Node.js e Couchbase N1QL. Se você ainda não o viu, o artigo é uma ótima introdução ao Couchbase e à criação de APIs RESTful usando Node.js e Express Framework. A desvantagem desse artigo, e não é uma desvantagem ruim, é que você precisa preferir escrever consultas SQL para gerenciar seus dados NoSQL.

E se você preferir usar um Modelo de Documento de Objeto (ODM) em vez de escrever consultas?

Desta vez, vamos explorar o processo de desenvolvimento por trás da criação de um encurtador de URL que usa Ottoman ODM, Couchbase Server e Node.js.

Os requisitos

Não há muitos requisitos para o sucesso desse aplicativo. Por exemplo, o que você precisará instalar e configurar é o seguinte:

Servidor Couchbase 4.1+
Node.js 4.0+

Como este é um aplicativo Node.js, precisaremos dele instalado e usaremos o Node Package Manager (NPM) para reunir todas as dependências do nosso projeto. Para aproveitar ao máximo o Ottoman, queremos usar o Couchbase 4.1 ou superior.

Entendendo o modelo de dados e preparando o banco de dados do Couchbase

Para este exemplo, vamos criar um bucket chamado exemplo no Couchbase Server. Você não precisa chamá-lo assim, mas ao longo do artigo faremos referência a ele como tal. Não é necessário nenhum índice ou configuração adicional em nosso cluster além da criação do bucket.

Em termos de dados, o plano é armazenar um documento para cada URL que desejamos reduzir. Cada documento pode ter a seguinte aparência:

{
  "_type": "Url",
  "hash": "2xmx9qpyj",
  "longUrl": "https://www.thepolyglotdeveloper.com/2016/05/using-couchbase-nosql-nativescript-angular-2-mobile-app/",
  "shortUrl": "http://localhost:3000/2xmx9qpyj"
}

{

"_type": "Url",

"hash": "2xmx9qpyj",

"longUrl": "https://www.thepolyglotdeveloper.com/2016/05/using-couchbase-nosql-nativescript-angular-2-mobile-app/",

"shortUrl": "http://localhost:3000/2xmx9qpyj"

}

O _tipo é algo definido pelo modelo Ottoman, mas as outras três são propriedades que definiremos. O hash representará um hash exclusivo de um valor. Esse hash funcionará como identificador em cada um de nossos URLs curtos.

Desenvolvimento do aplicativo encurtador de URL do Node.js

Com o banco de dados pronto e um entendimento básico do nosso modelo de dados, podemos trabalhar na criação do nosso aplicativo encurtador de URLs Node.js. O aplicativo dependerá muito do Express Framework e de uma biblioteca chamada Hashids. Usaremos Hashids para evitar o trabalho de escrever nosso próprio algoritmo de hash curto.

Criando o projeto com as dependências

Vamos começar criando um novo projeto Node.js e instalando todas as dependências necessárias do projeto. No Terminal (Mac e Linux) ou no Prompt de Comando (Windows), execute o seguinte:

npm init --y

1	npm inicial --y

O comando acima criará um novo package.json para o nosso projeto. Esse arquivo conterá todas as informações de dependência, além de outras coisas.

Agora, precisamos instalar cada uma das dependências necessárias em nosso projeto:

npm install couchbase express ottoman body-parser hashids --save

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

O comando acima instalará o SDK do Couchbase, a estrutura Express, o Ottoman, o Hashids e a biblioteca Body Parser para aceitar dados do corpo em solicitações HTTP.

Nesse ponto, podemos começar a inicializar o aplicativo para prepará-lo para o trabalho pesado.

Inicialização do aplicativo

Para simplificar, todo o código do nosso aplicativo residirá em um único arquivo dentro do nosso projeto chamado index.js. Em um ambiente de produção, você provavelmente desejaria dividi-lo para facilitar a manutenção, mas para este exemplo muito simples não haverá problema.

Abra o index.js e incluir importações para cada uma das dependências que instalamos:

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

var Couchbase = exigir("couchbase");

var Otomana = exigir("ottoman");

var Expresso = exigir("expresso");

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

var Hashids = exigir("hashids");

Com as dependências importadas, agora podemos inicializá-las para uso no aplicativo:

var app = Express();

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

var aplicativo = Expresso();

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

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

No exemplo acima, estamos basicamente dizendo que queremos inicializar o Express Framework e aceitar JSON e dados do corpo codificados por URL das solicitações.

Nesse ponto, podemos estabelecer uma conexão com nosso cluster do Couchbase e abrir o bucket do aplicativo:

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

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

Para usar o Ottoman, alguns índices precisam existir. Para nossa sorte, podemos fazer com que o Ottoman crie esses índices para nós se eles ainda não existirem. Depois de termos certeza de que eles existem, podemos começar a servir o aplicativo.

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

Otomana.ensureIndices(função(erro) {

se(erro) {

console.registro(erro);

}

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

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

});

Em nosso exemplo, o aplicativo será servido localmente na porta 3000.

Até agora, só temos a estrutura básica em funcionamento para nosso aplicativo encurtador de URL. Na verdade, não temos nenhuma lógica de encolhimento ou interação com o banco de dados em relação a operações CRUD ou de consulta.

Criação do modelo de dados

Sabemos como os dados serão exibidos no banco de dados, mas ainda não sabemos como criá-los. Como estamos usando um ODM em vez de consultas N1QL, precisamos definir o modelo em nosso código.

Nesse projeto específico, o modelo é muito simples. Ele seria parecido com o seguinte:

var UrlModel = Ottoman.model("Url", {
    hash: {type: "string", readonly: true},
    longUrl: "string",
    shortUrl: "string"
}, {
    id: "hash"
});

var UrlModel = Otomana.modelo("Url", {

hash: {tipo: "string", somente leitura: verdadeiro},

longUrl: "string",

shortUrl: "string"

}, {

id: "hash"

});

No modelo de dados acima, que estamos chamando de URLtemos três propriedades. As hash representará o ID do nosso documento. Não é obrigatório definir manualmente o ID do documento, mas para este projeto faz sentido. A definição manual de um id de documento exige que a propriedade seja somente leitura. As outras duas propriedades são valores de cadeia de caracteres padrão.

O modelo pode ser infinitamente mais complexo, dependendo de suas necessidades.

Aplicação do modelo de dados em uma série de métodos de ponto de extremidade RESTful

O aplicativo que estamos criando é um serviço da Web RESTful, portanto, precisamos criar algumas funções de endpoint. O aplicativo conterá os três endpoints públicos a seguir:

/
/create
/expand

/criar

/expandir

Quando o raiz for atingido, o aplicativo nos levará ao URL longo que está armazenado no Couchbase. Quando o /criar for atingido, tentaremos encontrar um URL curto salvo anteriormente ou criaremos um, caso ele não exista. Fazemos isso porque não queremos salvar várias cópias de um URL longo. Por fim, temos um /expandir para que possamos ver para onde vai nosso URL curto.

Começando com o /criar temos o seguinte método, que provavelmente é a parte mais complexa do nosso aplicativo:

app.post("/create", function(req, res) {
    if(!req.body.longUrl) {
        return res.status(400).send({"status": "error", "message": "A long URL is required"});
    }
    UrlModel.find({"longUrl": req.body.longUrl}, function(error, url) {
        if(error) {
            return res.status(400).send(error);
        }
        if(url.length == 0) {
            var hashids = new Hashids();
            var urlObj = new UrlModel({
                hash: hashids.encode((new Date).getTime()),
                longUrl: req.body.longUrl
            });
            urlObj.shortUrl = "http://localhost:3000/" + urlObj.hash;
            urlObj.save(function(error, result) {
                if(error) {
                    return res.status(400).send(error);
                }
                res.send(urlObj);
            });
        } else {
            res.send(url[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"});

}

UrlModel.encontrar({"longUrl": req.corpo.longUrl}, função(erro, url) {

se(erro) {

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

}

se(url.comprimento == 0) {

var hashids = novo Hashids();

var urlObj = novo UrlModel({

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

longUrl: req.corpo.longUrl

});

urlObj.shortUrl = "http://localhost:3000/" + urlObj.hash;

urlObj.salvar(função(erro, resultado) {

se(erro) {

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

}

res.enviar(urlObj);

});

} mais {

res.enviar(url[0]);

}

});

O endpoint acima é um endpoint de solicitação POST que espera um corpo. Se nenhuma URL longa for encontrada no corpo, será retornado um erro. Caso contrário, será feita uma pesquisa otomana com base no URL longo fornecido. Se forem encontrados dados na pesquisa, esses dados serão retornados ao usuário; caso contrário, será iniciado um processo para criar uma nova entrada.

Durante a criação da nova entrada, um hash exclusivo é criado com base no registro de data e hora. Esse hash é anexado a um nome de host curto e salvo no banco de dados junto com o próprio hash e a URL longa. O objeto é retornado após um salvamento bem-sucedido.

Quando se trata de /expandir temos o seguinte:

app.get("/expand", function(req, res) {
    if(!req.query.shortUrl) {
        return res.status(400).send({"status": "error", "message": "A short URL is required"});
    }
    UrlModel.find({"shortUrl": req.query.shortUrl}, function(error, url) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(url.length &gt; 0 ? url[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"});

}

UrlModel.encontrar({"shortUrl": req.consulta.shortUrl}, função(erro, url) {

se(erro) {

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

}

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

});

O método é semelhante ao que vimos no /criar mas não é exatamente o mesmo. Em vez disso, fazemos uma pesquisa com base no URL curto fornecido. Se for encontrado, retornamos o documento que contém o URL longo; caso contrário, retornamos um objeto vazio.

Por fim, temos o raiz endpoint. Esse endpoint é responsável pelo redirecionamento para o URL longo e requer um ID que, na realidade, é o nosso hash. Lembre-se de que estamos hospedando a API e os URLs curtos no mesmo servidor.

app.get("/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An id is required"});
    }
    UrlModel.getById(req.params.id, function(error, url) {
        if(error) {
            return res.status(400).send(error);
        }
        res.redirect(url.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"});

}

UrlModel.getById(req.parâmetros.id, função(erro, url) {

se(erro) {

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

}

res.redirecionar(url.longUrl);

});

Então, digamos que navegamos para http://localhost:3000/2xmx9qpyj no navegador. Os 2xmx9qpyj é o nosso ID, que também é o nosso valor de hash. Podemos fazer uma pesquisa de documento com base nesse ID e navegar se ele existir.

Não é tão ruim, certo?

O código-fonte completo do aplicativo

Caso queira ver o aplicativo completo reunido, você pode encontrá-lo abaixo.

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

var app = Express();

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

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

var UrlModel = Ottoman.model("Url", {
    hash: {type: "string", readonly: true},
    longUrl: "string",
    shortUrl: "string"
}, {
    id: "hash"
});

app.get("/expand", function(req, res) {
    if(!req.query.shortUrl) {
        return res.status(400).send({"status": "error", "message": "A short URL is required"});
    }
    UrlModel.find({"shortUrl": req.query.shortUrl}, function(error, url) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(url.length &gt; 0 ? url[0] : {});
    });
});

app.post("/create", function(req, res) {
    if(!req.body.longUrl) {
        return res.status(400).send({"status": "error", "message": "A long URL is required"});
    }
    UrlModel.find({"longUrl": req.body.longUrl}, function(error, url) {
        if(error) {
            return res.status(400).send(error);
        }
        if(url.length == 0) {
            var hashids = new Hashids();
            var urlObj = new UrlModel({
                hash: hashids.encode((new Date).getTime()),
                longUrl: req.body.longUrl
            });
            urlObj.shortUrl = "http://localhost:3000/" + urlObj.hash;
            urlObj.save(function(error, result) {
                if(error) {
                    return res.status(400).send(error);
                }
                res.send(urlObj);
            });
        } else {
            res.send(url[0]);
        }
    });
});

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

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

var Couchbase = exigir("couchbase");

var Otomana = exigir("ottoman");

var Expresso = exigir("expresso");

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

var Hashids = exigir("hashids");

var aplicativo = Expresso();

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

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

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

var UrlModel = Otomana.modelo("Url", {

hash: {tipo: "string", somente leitura: verdadeiro},

longUrl: "string",

shortUrl: "string"

}, {

id: "hash"

});

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"});

}

UrlModel.encontrar({"shortUrl": req.consulta.shortUrl}, função(erro, url) {

se(erro) {

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

}

res.enviar(url.comprimento > 0 ? url[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"});

}

UrlModel.encontrar({"longUrl": req.corpo.longUrl}, função(erro, url) {

se(erro) {

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

}

se(url.comprimento == 0) {

var hashids = novo Hashids();

var urlObj = novo UrlModel({

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

longUrl: req.corpo.longUrl

});

urlObj.shortUrl = "http://localhost:3000/" + urlObj.hash;

urlObj.salvar(função(erro, resultado) {

se(erro) {

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

}

res.enviar(urlObj);

});

} mais {

res.enviar(url[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"});

}

UrlModel.getById(req.parâmetros.id, função(erro, url) {

se(erro) {

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

}

res.redirecionar(url.longUrl);

});

Otomana.ensureIndices(função(erro) {

se(erro) {

console.registro(erro);

}

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

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

});

Se você executar o código acima com npm index.js você pode começar a usar cada um dos pontos de extremidade da API encontrados em http://localhost:3000.

Conclusão

Você acabou de ver como criar um aplicativo encurtador de URL usando um modelo de documento de objeto (ODM) chamado Ottoman, Couchbase Server e Node.js. Se não for fã de ODMs ou se quiser ver como fazer isso com consultas SQL, você pode conferir um tutorial anterior Escrevi sobre o assunto.

Deseja levar este tutorial um passo adiante? Por que não tentar coletar informações analíticas das pessoas que tentam usar os URLs curtos? Você pode manter um contador de ocorrências dentro dos documentos antes da navegação ou até mesmo armazenar informações como agentes de usuário do navegador.

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 usando Ottoman ODM com Node.js e Couchbase

Os requisitos

Entendendo o modelo de dados e preparando o banco de dados do Couchbase

Desenvolvimento do aplicativo encurtador de URL do Node.js

Criando o projeto com as dependências

Inicialização do aplicativo

Criação do modelo de dados

Aplicação do modelo de dados em uma série de métodos de ponto de extremidade RESTful

O código-fonte completo do aplicativo

Conclusão

Autor

Postado por Nic Raboy, defensor dos desenvolvedores, Couchbase

Deixar uma resposta Cancelar resposta