Node.js Game Server Framework & Development Architecture

Há alguns anos, Brett Lawson fez uma ótima série de blogs sobre o uso do Couchbase Server e do Node.js para o desenvolvimento de uma estrutura de servidor de jogos. Desde então, o SDK do Node.js para o Couchbase cresceu significativamente da versão 1.x para a 2.x.

Neste artigo, vamos revisitar essas três postagens originais e alterá-las para que fiquem em dia com os padrões mais recentes do Node.js e do Express Framework, bem como com a versão mais recente do Node.js SDK do Couchbase.

Os pré-requisitos

Node.js 0.12
Servidor Couchbase 4.0

Preparação do projeto

Quer você esteja no Mac, no Windows ou no Linux, a criação de um novo aplicativo do Express Framework deve ser consistente entre eles. Crie um novo diretório chamado gameapi-nodejs provavelmente em sua área de trabalho e, no Terminal (Mac/Linux) ou no Prompt de Comando (Windows), execute o seguinte comando:


npm init

npm inicial

Responda às perguntas feitas da melhor forma possível. Obviamente, o diretório do projeto deve ser seu diretório atual no prompt de comando ou no terminal para que isso seja bem-sucedido. Como alternativa ao comando, você pode criar e preencher esse arquivo manualmente. Crie um novo arquivo chamado package.json no diretório do seu projeto e preencha-o com o seguinte:


{
  "name": "gameapi-nodejs",
  "version": "1.0.0",
  "description": "An example of using the Node.js SDK for Couchbase to create a simple game server",
  "author": "Couchbase, Inc.",
  "license": "MIT"
}

{

"name" (nome): "gameapi-nodejs",

"versão": "1.0.0",

"description" (descrição): "Um exemplo de uso do SDK do Node.js para o Couchbase para criar um servidor de jogos simples",

"autor": "Couchbase, Inc.",

"licença": "MIT"

}

Ainda não terminamos. Precisamos instalar as dependências do projeto antes de começarmos a planejar o aplicativo. No prompt de comando ou no terminal, execute o seguinte comando:


npm install body-parser couchbase express node-forge uuid --save

npm instalar corpo-analisador couchbase expresso nó-forjar uuid --salvar

Isso instalará o Express Framework, o SDK do Couchbase Node.js, o Forge para hashing de senha, o UUID para gerar valores exclusivos e o middleware body-parser para lidar com dados POST codificados por URL e JSON.

Preparando o banco de dados

Antes de começarmos a codificar, o Couchbase Server deve ser instalado com um bucket chamado amostra de jogos criado.

Como este projeto fará uso de um recurso importante do Couchbase 4.0, precisaremos configurar ainda mais o bucket para que seja criado um índice primário. Se você estiver usando uma máquina Linux, Mac ou Windows, isso pode ser feito facilmente por meio do cliente Couchbase Query (CBQ).

Mac

Para abrir o CBQ no Mac, no Terminal, execute o seguinte:


./Applications/Couchbase Server.app/Contents/Resources/couchbase-core/bin/cbq

./Aplicativos/Couchbase Servidor.aplicativo/Conteúdo/Recursos/couchbase-núcleo/caixa/cbq

Windows

Para abrir o CBQ no Windows, no prompt de comando, execute o seguinte:


C:/Program Files/Couchbase/Server/bin/cbq.exe

C:/Programa Arquivos/Couchbase/Servidor/caixa/cbq.exe

Criação de um índice primário

Com o CBQ aberto, execute o seguinte:


CREATE PRIMARY INDEX ON `gaming-sample` using GSI;

CRIAR PRIMÁRIO ÍNDICE ON `jogos-amostra` usando GSI;

Seu balde agora está pronto para ser usado com o restante do projeto!

A estrutura do projeto

Nosso projeto será composto do seguinte:

Item	Pais	Descrição
modelos		Todos os arquivos de classe do banco de dados serão colocados aqui
rotas		Todas as definições de pontos de extremidade da API serão colocadas aqui
accountmodel.js	modelos	Criação e recuperação de informações de conta
sessionmodel.js	modelos	Autenticação de usuários e manutenção das informações da sessão
statemodel.js	modelos	Criar, atualizar e recuperar informações sobre o estado do jogo
rotas.js	rotas	Todos os pontos de extremidade para GET, POST, PUT estarão aqui
app.js		Informações de configuração do servidor
config.json		Variáveis estáticas
package.json		Informações de dependência

O básico

Antes de nos aprofundarmos na lógica do servidor de jogos do Node.js, é melhor configurar o aplicativo básico do Express Framework.

Na raiz do projeto, crie e abra um arquivo chamado config.json pois ele conterá informações estáticas, como as informações de conectividade do Couchbase. Inclua o seguinte quando ele estiver aberto:


{
    "couchbase": {
        "server": "127.0.0.1:8091",
        "bucket": "gaming-sample"
    }
}

{

"couchbase": {

"servidor": "127.0.0.1:8091",

"bucket" (balde): "amostra de jogos"

}

Na raiz do projeto, crie e abra um arquivo chamado app.js pois ele conterá todas as informações básicas sobre a execução do servidor Node.js. Inclua o seguinte quando abrir o arquivo:


var express = require("express");
var bodyParser = require("body-parser");
var couchbase = require("couchbase");
var config = require("./config");
var app = express();

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

// Global declaration of the Couchbase server and bucket to be used
module.exports.bucket = (new couchbase.Cluster(config.couchbase.server)).openBucket(config.couchbase.bucket);

// All endpoints to be used in this application
var routes = require("./routes/routes.js")(app);

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

var expresso = exigir("expresso");

var bodyParser = exigir("body-parser");

var couchbase = exigir("couchbase");

var configuração = exigir("./config");

var aplicativo = expresso();

aplicativo.uso(bodyParser.json());

aplicativo.uso(bodyParser.codificado por url({ estendido: verdadeiro }));

// Declaração global do servidor Couchbase e do bucket a ser usado

módulo.exportações.balde = (novo couchbase.Aglomerado(configuração.couchbase.servidor)).openBucket(configuração.couchbase.balde);

// Todos os pontos de extremidade a serem usados nesse aplicativo

var rotas = exigir("./routes/routes.js")(aplicativo);

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

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

});

Vamos detalhar o que vemos aqui. As primeiras linhas são a inclusão das dependências em nosso aplicativo. Não há nada de especial nisso. O que é importante é o seguinte:


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

aplicativo.uso(bodyParser.json());

aplicativo.uso(bodyParser.codificado por url({ estendido: verdadeiro }));

Isso significa que analisaremos os dados JSON e os dados codificados por URL dos corpos das solicitações. Em particular, solicitações POST e PUT. A próxima coisa que faremos é inicializar o cluster do Couchbase no aplicativo e abrir um único bucket para uso no aplicativo:


module.exports.bucket = (new couchbase.Cluster(config.couchbase.server)).openBucket(config.couchbase.bucket);

módulo.exportações.balde = (novo couchbase.Aglomerado(configuração.couchbase.servidor)).openBucket(configuração.couchbase.balde);

Ao incluir module.exports.bucket estamos dizendo que vamos usá-lo por meio do aplicativo. Agora, em outros arquivos JavaScript, se quisermos acessar o bucket, basta fazer isso:


var bucket = require("relative/path/to/app").bucket;

var balde = exigir("relative/path/to/app").balde;

Em seguida, você verá que incluímos nosso rotas/routes.js e passando a ele o arquivo aplicativo como um dos argumentos. O que isso faz será óbvio em breve.

Por fim, ao chamar app.listen estamos dizendo ao Node.js para escutar solicitações na porta 3000. O aplicativo está quase utilizável em seu estado mais básico. Criar e abrir rotas/routes.js e adicione as seguintes linhas:


var appRouter = function(app) {

    app.get("/", function(req, res) {
        res.status(403).send("Not a valid endpoint");
    });

}

module.exports = appRouter;

var appRouter = função(aplicativo) {

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

res.status(403).enviar("Não é um ponto de extremidade válido");

});

}

módulo.exportações = appRouter;

Agora, o aplicativo pode ser executado com a execução de nó app.js no prompt de comando ou no terminal. Aterrissando em http://localhost:3000 deve lhe dar a mensagem "Not a valid endpoint" (Não é um endpoint válido).

O modelo de dados da API

Antes de mergulhar no código que interessa, é melhor saber como os dados ficarão no Couchbase. Para qualquer usuário, haverá quatro documentos com a seguinte aparência:

O documento do usuário

O documento do usuário conterá todas as informações sobre um usuário. Para este aplicativo, essas informações serão um nome, um nome de usuário e uma senha.
O nome desse documento será prefixado com usuário:: e ter um valor uid exclusivo anexado a ele. Essa estratégia de nomeação de documentos usa o que é chamado de chaves compostas.


{
    "type": "user",
    "uid", "",
    "name": "",
    "username": "",
    "password": ""
}

{

"tipo": "usuário",

"uid", "",

"name" (nome): "",

"nome de usuário": "",

"senha": ""

}

O documento de nome de usuário

O documento de nome de usuário conterá apenas o valor uid encontrado no documento de usuário. A finalidade do documento de nome de usuário pode ser considerada como um documento de método de login. Por exemplo, ele poderia representar um login simples em que o usuário digita um nome de usuário e uma senha. Como o documento contém o uid de vinculação, ele pode ser vinculado ao documento do usuário. O documento de nome de usuário é prefixado com nome de usuário:: e o nome de usuário real é anexado a ele. Uma estratégia semelhante pode ser usada se estiver usando o Facebook ou o Twitter como métodos de login e vinculando-os também por meio do campo uid.


{
    "type": "username",
    "uid": ""
}

{

"tipo": "nome de usuário",

"uid": ""

}

O documento da sessão

O documento de sessão é um documento com expiração automática que atua como uma rota do usuário para informações mais seguras. Em teoria, o front-end do usuário armazenará o valor sid e o transmitirá entre os pontos de extremidade protegidos. Com ele, um uid vinculado a um usuário pode ser acessado.


{
    "type": "session",
    "sid": "",
    "uid": ""
}

{

"tipo": "sessão",

"sid": "",

"uid": ""

}

O documento do Estado

O documento de estado conterá informações sobre o estado específico do jogo. Por exemplo, se o personagem do jogo tiver cinco vidas restantes e vinte poções, essas informações serão salvas aqui. Há informações de versão para evitar que conflitos entre duas sessões de jogo ativas sejam salvos na mesma conta.


{
    "type": "state",
    "uid": "",
    "states": {
        "state-name": {
            "version": 1,
            "data": { }
        }
    }
}

{

"tipo": "estado",

"uid": "",

"estados": {

"state-name" (nome do estado): {

"versão": 1,

"dados": { }

}

Criação do modelo de conta

O modelo de conta servirá a três propósitos específicos:

Criação de uma conta de usuário
Recuperação de uma conta de usuário
Comparação de uma senha com hash com uma senha sem hash

Antes de começarmos a codificar, precisamos colocar nossos includes em ordem. Adicione o seguinte ao topo do arquivo models/accountmodel.js file:


var uuid = require("uuid");
var forge = require("node-forge");
var db = require("../app").bucket;
var N1qlQuery = require('couchbase').N1qlQuery;

var uuid = exigir("uuid");

var forjar = exigir("node-forge");

var db = exigir("../app").balde;

var N1qlQuery = exigir('couchbase').N1qlQuery;

Com base no modelo de dados visto acima, a criação de uma conta de usuário exigirá um nome, um nome de usuário e uma senha. Com essas informações em mãos, a senha será transformada em hash e as informações do usuário serão armazenadas ao lado de um documento de referência da seguinte forma:


AccountModel.create = function(params, callback) {
    var userDoc = {
        type: "user",
        uid: uuid.v4(),
        name: params.name,
        username: params.username,
        password: forge.md.sha1.create().update(params.password).digest().toHex()
    };
    var referenceDoc = {
        type: "username",
        uid: userDoc.uid
    };
    db.insert("username::" + userDoc.username, referenceDoc, function(error) {
        if(error) {
            callback(error, null);
            return;
        }
        db.insert("user::" + userDoc.uid, userDoc, function(error, result) {
            if(error) {
                callback(error, null);
                return;
            }
            callback(null, {message: "success", data: result});
        });
    });
};

AccountModel.criar = função(parâmetros, retorno de chamada) {

var userDoc = {

tipo: "usuário",

uid: uuid.v4(),

nome: parâmetros.nome,

nome de usuário: parâmetros.nome de usuário,

senha: forjar.md.sha1.criar().atualização(parâmetros.senha).resumo().toHex()

};

var referenceDoc = {

tipo: "nome de usuário",

uid: userDoc.uid

};

db.inserir("nome de usuário::" + userDoc.nome de usuário, referenceDoc, função(erro) {

se(erro) {

retorno de chamada(erro, nulo);

retorno;

}

db.inserir("user::" + userDoc.uid, userDoc, função(erro, resultado) {

se(erro) {

retorno de chamada(erro, nulo);

retorno;

}

retorno de chamada(nulo, {mensagem: "sucesso", dados: resultado});

});

};

Observe que no código acima, primeiro tentamos inserir um novo documento de referência. Se houver falha (talvez ele já exista), nenhum dos documentos será salvo e, em vez disso, a mensagem de erro será retornada. Independentemente de ser um sucesso ou uma falha, o retorno de chamada do arquivo de rotas é executado para exibir qualquer tipo de resposta ao solicitante.

Em termos de leitura de dados do usuário, uma das duas coisas pode acontecer. Poderíamos passar um nome de usuário, porque estamos fazendo um login simples, ou poderíamos passar um ID de usuário. Depende do que estamos buscando. Digamos que estejamos apenas fazendo login com o nome de usuário, você provavelmente desejaria chamar uma função como esta:


AccountModel.getByUsername = function(params, callback) {
    var query = N1qlQuery.fromString(
        "select users.* from `gaming-sample` as usernames " +
        "join `gaming-sample` as users on keys ("user::" || usernames.uid) " +
        "where meta(usernames).id = $1"
    );
    db.query(query, ["username::" + params.username], function(error, result) {
        if(error) {
            return callback(error, null);
        }
        callback(null, result);
    });
};

AccountModel.getByUsername = função(parâmetros, retorno de chamada) {

var consulta = N1qlQuery.fromString(

"select users.* from `gaming-sample` as usernames" +

"join `gaming-sample` as users on keys ("usuário::" || usernames.uid) " +

"where meta(usernames).id = $1"

);

db.consulta(consulta, ["nome de usuário::" + parâmetros.nome de usuário], função(erro, resultado) {

se(erro) {

retorno retorno de chamada(erro, nulo);

}

retorno de chamada(nulo, resultado);

});

};

Observe como estamos usando uma consulta N1QL, nova no Couchbase 4.0. Ela é muito semelhante ao SQL tradicional e também nos dá a conveniência de não precisarmos processar ou formatar dados na camada do aplicativo. O Couchbase Server fará tudo isso por nós. No entanto, temos a opção de solicitar dados como nas versões mais antigas do Couchbase e em outras plataformas NoSQL.

Na instrução N1QL acima, estamos selecionando um documento com a chave composta anexada ao nosso nome de usuário em texto simples. Está ocorrendo uma união com a propriedade uid do documento usernames (chave externa) e o documento users (chave primária).

Isso nos leva à validação de uma senha. Não há chamadas ao banco de dados aqui. Simplesmente pegaremos uma senha bruta, faremos o hash dela e, em seguida, compararemos o hash com a senha armazenada.


AccountModel.validatePassword = function(rawPassword, hashedPassword) {
    return forge.md.sha1.create().update(rawPassword).digest().toHex() === hashedPassword ? true : false;
};

AccountModel.validatePassword = função(rawPassword, hashedPassword) {

retorno forjar.md.sha1.criar().atualização(rawPassword).resumo().toHex() === hashedPassword ? verdadeiro : falso;

};

Para fazer models/accountmodel.js utilizável em nosso arquivo de rotas, devemos exportá-lo da seguinte forma na parte inferior do arquivo
models/accountmodel.js código:


module.exports = AccountModel;

módulo.exportações = AccountModel;

Criação do modelo de sessão

O modelo de sessão servirá a três propósitos específicos:

Criação de uma sessão de usuário
Recuperação de uma sessão de usuário
Validação de uma sessão de usuário

Antes de começarmos a codificar, precisamos colocar nossos includes em ordem. Adicione o seguinte ao topo do arquivo models/sessionmodel.js file:


var uuid = require("uuid");
var db = require("../app").bucket;

var uuid = exigir("uuid");

var db = exigir("../app").balde;

Criação de uma sessão

Quando um usuário deseja criar uma sessão, é necessário fornecer um uid. Com isso em mãos, um ID de sessão exclusivo é criado e inserido no banco de dados com uma expiração. Quando o documento expirar, ele será automaticamente removido do Couchbase sem nenhuma intervenção do usuário, fazendo assim o logout do usuário.


SessionModel.create = function(uid, callback) {
    var sessionDoc = {
        type: "session",
        sid: uuid.v4(),
        uid: uid
    };
    db.insert("session::" + sessionDoc.sid, sessionDoc, {"expiry": 3600}, function(error, result) {
        if(error) {
            callback(error, null);
            return;
        }
        callback(null, sessionDoc.sid);
    });
};

SessionModel.criar = função(uid, retorno de chamada) {

var sessionDoc = {

tipo: "sessão",

lado: uuid.v4(),

uid: uid

};

db.inserir("session::" + sessionDoc.lado, sessionDoc, {"expiração": 3600}, função(erro, resultado) {

se(erro) {

retorno de chamada(erro, nulo);

retorno;

}

retorno de chamada(nulo, sessionDoc.lado);

});

};

Autenticação de um usuário

Com a sessão de usuário criada, o ID da sessão deve ser usado sempre que o usuário quiser acessar um endpoint protegido.


SessionModel.authenticate = function(req, res, next) {
    if(!req.headers.authorization) {
        next("Must be authorized to use");
    }
    var authInfo = req.headers.authorization.split(" ");
    if(authInfo[0] === "Bearer") {
        var sid = authInfo[1];
        SessionModel.get(sid, function(error, result) {
            if(error) {
                return next(error);
            }
            SessionModel.refresh(sid, function() {});
            req.uid = result.value.uid;
            next();
        });
    }
};

SessionModel.autenticar = função(req, res, próxima) {

se(!req.cabeçalhos.autorização) {

próxima("Deve ser autorizado a usar");

}

var authInfo = req.cabeçalhos.autorização.dividir(" ");

se(authInfo[0] === "Portador") {

var lado = authInfo[1];

SessionModel.obter(lado, função(erro, resultado) {

se(erro) {

retorno próxima(erro);

}

SessionModel.atualizar(lado, função() {});

req.uid = resultado.valor.uid;

próxima();

});

}

};

No código acima, a função receberá um ID de sessão que será usado para verificar se já existe uma sessão. Em caso afirmativo, ela redefinirá o tempo de expiração da sessão e retornará o uid associado a ela. A obtenção das informações da sessão pode ser vista da seguinte forma:


SessionModel.get = function(sid, callback) {
    db.get("session::" + sid, function(error, result) {
        if(error) {
            callback(error, null);
            return;
        }
        callback(null, result);
    });
};

SessionModel.obter = função(lado, retorno de chamada) {

db.obter("session::" + lado, função(erro, resultado) {

se(erro) {

retorno de chamada(erro, nulo);

retorno;

}

retorno de chamada(nulo, resultado);

});

};

Nada mal, certo? Por fim, você pode ver que a redefinição da sessão ocorre de maneira semelhante:


SessionModel.refresh = function(sid, callback) {
    db.touch("session::" + sid, 3600, function(error, result) {
        if(error) {
            callback(error, null);
        }
    });
};

SessionModel.atualizar = função(lado, retorno de chamada) {

db.toque("session::" + lado, 3600, função(erro, resultado) {

se(erro) {

retorno de chamada(erro, nulo);

}

});

};

O método de toque não adicionará tempo, mas sim redefinirá o tempo. Nesse caso, ele redefinirá o cronômetro para uma hora

Para fazer models/sessionmodel.js utilizável em nosso arquivo de rotas, devemos exportá-lo da seguinte forma na parte inferior do arquivo models/sessionmodel.js código:


module.exports = SessionModel;

módulo.exportações = SessionModel;

Criação do modelo de estado

O modelo de estado servirá a dois propósitos específicos:

Criação ou atualização de um estado salvo
Recuperação de um save-state por nome

Antes de começarmos a codificar, precisamos colocar nossos includes em ordem. Adicione o seguinte ao topo do arquivo models/statemodel.js file:


var uuid = require("uuid");
var couchbase = require("couchbase");
var N1qlQuery = require('couchbase').N1qlQuery;
var db = require("../app").bucket;

var uuid = exigir("uuid");

var couchbase = exigir("couchbase");

var N1qlQuery = exigir('couchbase').N1qlQuery;

var db = exigir("../app").balde;

Criação de um estado de salvamento

O objetivo por trás da criação ou atualização de um save-state é que primeiro verificaremos se existe um. Se não existir, nós o criaremos. Se existir, obteremos as informações existentes, as alteraremos e substituiremos as informações existentes no banco de dados. Tudo isso é feito enquanto aumentamos a versão do estado para evitar conflitos entre os salvamentos de jogos. Na verdade, não é para evitar conflitos ao salvar no Couchbase, apenas para garantir que você não pegue o jogo em dois dispositivos e substitua os dados do jogo por um salvamento muito mais antigo.


StateModel.save = function(uid, name, preVer, data, callback) {
    db.get("user::" + uid + "::state", function(error, result) {
        if(error &amp;&amp; error.code !== couchbase.errors.keyNotFound) {
            callback(error, null);
            return;
        }
        var stateDoc = {
            type: "state",
            uid: uid,
            states: {}
        };
        if(result != null &amp;&amp; result.value) {
            stateDoc = result.value;
        }
        var stateBlock = {
            version: 0,
            data: null
        };
        if(stateDoc.states[name]) {
            stateBlock = stateDoc.states[name];
        } else {
            stateDoc.states[name] = stateBlock;
        }
        if(stateBlock.version !== preVer) {
            return callback({"status": "error", "message": "Your version does not match the server version"});
        } else {
            stateBlock.version++;
            stateBlock.data = data;
        }
        var stateOptions = {};
        if(result != null &amp;&amp; result.value) {
            stateOptions.cas = result.cas;
        }
        db.upsert("user::" + uid + "::state", stateDoc, stateOptions, function(error, result) {
            if(error) {
                return callback(error, null);
            }
            callback(null, stateBlock);
        });
    });
};

Modelo de Estado.salvar = função(uid, nome, preVer, dados, retorno de chamada) {

db.obter("user::" + uid + "::state", função(erro, resultado) {

se(erro &amplificador;&amplificador; erro.código !== couchbase.erros.keyNotFound) {

retorno de chamada(erro, nulo);

retorno;

}

var documento de estado = {

tipo: "estado",

uid: uid,

estados: {}

};

se(resultado != nulo &amplificador;&amplificador; resultado.valor) {

documento de estado = resultado.valor;

}

var stateBlock = {

versão: 0,

dados: nulo

};

se(documento de estado.estados[nome]) {

stateBlock = documento de estado.estados[nome];

} mais {

documento de estado.estados[nome] = stateBlock;

}

se(stateBlock.versão !== preVer) {

retorno retorno de chamada({"status": "error" (erro), "mensagem": "Sua versão não corresponde à versão do servidor"});

} mais {

stateBlock.versão++;

stateBlock.dados = dados;

}

var stateOptions = {};

se(resultado != nulo &amplificador;&amplificador; resultado.valor) {

stateOptions.cas = resultado.cas;

}

db.upsert("user::" + uid + "::state", documento de estado, stateOptions, função(erro, resultado) {

se(erro) {

retorno retorno de chamada(erro, nulo);

}

retorno de chamada(nulo, stateBlock);

});

};

Veja o upsert lá. No Couchbase, isso significa criar, caso não exista, ou substituir, caso exista. Muito conveniente para coisas como salvar estados de um jogo.

Obtendo os estados

Isso nos permite obter qualquer estado salvo que possamos ter criado.


StateModel.getByUserIdAndName = function(uid, name, callback) {
    db.get("user::" + uid + "::state", function(error, result) {
        if(error) {
            if(error.code !== couchbase.errors.keyNotFound) {
                return callback(null, {});
            } else {
                return callback(error, null);
            }
        }
        if(!result.value.states[name]) {
            return callback({"status": "error", "message": "State does not exist"}, null);
        }
        callback(null, result.value.states[name]);
    });
};

Modelo de Estado.getByUserIdAndName = função(uid, nome, retorno de chamada) {

db.obter("user::" + uid + "::state", função(erro, resultado) {

se(erro) {

se(erro.código !== couchbase.erros.keyNotFound) {

retorno retorno de chamada(nulo, {});

} mais {

retorno retorno de chamada(erro, nulo);

}

se(!resultado.valor.estados[nome]) {

retorno retorno de chamada({"status": "error" (erro), "mensagem": "O Estado não existe"}, nulo);

}

retorno de chamada(nulo, resultado.valor.estados[nome]);

});

};

O conceito por trás disso é que estamos fazendo uma pesquisa de documento com base em um ID de usuário. Se o documento de estado para um determinado uid existir, faça uma pesquisa na matriz associativa para ver se o nome do estado existe. Se existir, retorne qualquer conteúdo de estado existente para o nome.

Para fazer models/statemodel.js utilizável em nosso arquivo de rotas, devemos exportá-lo da seguinte forma na parte inferior do arquivo models/statemodel.js código:


module.exports = StateModel;

módulo.exportações = Modelo de Estado;

Criação das rotas de API

Criamos todos os modelos de dados necessários acima, então é hora de unir tudo isso com rotas acessíveis ao usuário. Voltando à seção rotas/routes.js começaremos adicionando as rotas do modelo de conta:


app.post("/api/user", function(req, res) {
    if(!req.body.name) {
        return res.status(400).send({"status": "error", "message": "A name is required"});
    } else if(!req.body.username) {
        return res.status(400).send({"status": "error", "message": "A username is required"});
    } else if(!req.body.password) {
        return res.status(400).send({"status": "error", "message": "A password is required"});
    }
    AccountModel.create(req.body, function(error, result) {
        if(error) {
            return res.status(400).send(error);
        }
        res.send(result);
    });
});

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

se(!req.corpo.nome) {

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

} mais se(!req.corpo.nome de usuário) {

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

} mais se(!req.corpo.senha) {

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

}

AccountModel.criar(req.corpo, função(erro, resultado) {

se(erro) {

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

}

res.enviar(resultado);

});

O endpoint acima espera uma solicitação POST com um parâmetro de corpo nome, nome de usuário e senha. Estamos ouvindo o POST porque é uma prática recomendada usar o POST ao criar ou inserir dados por meio de uma solicitação HTTP. Se todos os três existirem, então o AccountModel.create() é chamado e, por fim, retorna um erro ou um resultado, dependendo do sucesso do método. Se pelo menos um dos parâmetros necessários não existir, será retornado um erro. Uma lista de códigos de erro pode ser vista aqui.

Um ponto de extremidade para obter informações do usuário não é tão importante neste exemplo, portanto, iremos direto para a autenticação do usuário e a criação de uma sessão. Na seção rotas/routes.js adicione o seguinte:


app.get("/api/auth", function(req, res, next) {
    if(!req.query.username) {
        return next(JSON.stringify({"status": "error", "message": "A username must be provided"}));
    }
    if(!req.query.password) {
        return next(JSON.stringify({"status": "error", "message": "A password must be provided"}));
    }
    AccountModel.getByUsername(req.query, function(error, user) {
        if(error) {
            return res.status(400).send(error);
        }
        if(!AccountModel.validatePassword(req.query.password, user[0].password)) {
            return res.send({"status": "error", "message": "The password entered is invalid"});
        }
        SessionModel.create(user[0].uid, function(error, result) {
            if(error) {
                return res.status(400).send(error);
            }
            res.setHeader("Authorization", "Bearer " + result);
            res.send(user);
        });
    });
});

aplicativo.obter("/api/auth", função(req, res, próxima) {

se(!req.consulta.nome de usuário) {

retorno próxima(JSON.stringify({"status": "error" (erro), "mensagem": "Um nome de usuário deve ser fornecido"}));

}

se(!req.consulta.senha) {

retorno próxima(JSON.stringify({"status": "error" (erro), "mensagem": "Uma senha deve ser fornecida"}));

}

AccountModel.getByUsername(req.consulta, função(erro, usuário) {

se(erro) {

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

}

se(!AccountModel.validatePassword(req.consulta.senha, usuário[0].senha)) {

retorno res.enviar({"status": "error" (erro), "mensagem": "A senha digitada é inválida"});

}

SessionModel.criar(usuário[0].uid, função(erro, resultado) {

se(erro) {

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

}

res.setHeader("Authorization" (Autorização), "Portador" + resultado);

res.enviar(usuário);

});

O ponto de extremidade de autenticação espera um nome de usuário e uma senha. Se ambos forem encontrados, o usuário será procurado. Se o usuário for encontrado, será feita uma comparação de senhas e, se for bem-sucedida, será criada uma sessão.

Os dois últimos pontos de extremidade da API que são úteis para nós são para obter e criar estados salvos. Começando com a criação de um endpoint de estado salvo, em seu rotas/routes.jsAdicione o seguinte:


app.put("/api/state/:name", SessionModel.authenticate, function(req, res, next) {
    StateModel.save(req.uid, req.params.name, parseInt(req.query.preVer, 10), req.body, function(error, result) {
        if(error) {
            return res.send(error);
        }
        res.send(result);
    });
});

aplicativo.colocar("/api/state/:name", SessionModel.autenticar, função(req, res, próxima) {

Modelo de Estado.salvar(req.uid, req.parâmetros.nome, parseInt(req.consulta.preVer, 10), req.corpo, função(erro, resultado) {

se(erro) {

retorno res.enviar(erro);

}

res.enviar(resultado);

});

O endpoint acima espera um parâmetro de URL que representa o nome do estado, um parâmetro de consulta que representa a versão atual do estado e um corpo de solicitação que pode conter qualquer JSON imaginável, pois representa os dados do jogo que vale a pena salvar.

Por fim, resta-nos obter os estados que foram salvos.


app.get("/api/state/:name", SessionModel.authenticate, function(req, res, next) {
    StateModel.getByUserIdAndName(req.uid, req.params.name, function(error, result) {
        if(error) {
            return res.send(error);
        }
        res.send(result);
    });
});

aplicativo.obter("/api/state/:name", SessionModel.autenticar, função(req, res, próxima) {

Modelo de Estado.getByUserIdAndName(req.uid, req.parâmetros.nome, função(erro, resultado) {

se(erro) {

retorno res.enviar(erro);

}

res.enviar(resultado);

});

O ponto de extremidade acima espera um parâmetro de URL que represente o estado de salvamento específico a ser encontrado. É claro que ele também espera que o usuário seja autenticado primeiro.

Testando a API

Os pontos de extremidade da API que criamos no rotas/routes.js pode ser testado de várias maneiras. Duas das minhas formas favoritas de testar são com a extensão Postman para o Chrome ou com o cURL. Experimente você mesmo usando o cURL:


curl -X POST http://localhost:3000/api/user --data "name=Nic%20Raboy&amp;username=nraboy&amp;password=12345"

RESPONSE:

{
    "message": "success",
    "data": {
        "cas": "16588775686144"
    }
}

enrolar -X POST http://localhost:3000/api/user --data "name=Nic%20Raboy&username=nraboy&password=12345"

RESPOSTA:

{

"mensagem": "sucesso",

"dados": {

"cas": "16588775686144"

}

Acima, fomos em frente e criamos uma nova conta de usuário


curl -X GET "http://localhost:3000/api/auth?username=nraboy&amp;password=12345"

RESPONSE:

[
    {
        "name": "Nic Raboy",
        "password": "8cb2237d0679ca88db6464eac60da96345513964",
        "type": "user",
        "uid":"c3e834b0-867e-4a43-aede-b15a4e139adc",
        "username": "nraboy"
    }
]

enrolar -X OBTER "http://localhost:3000/api/auth?username=nraboy&password=12345"

RESPOSTA:

[

{

"name" (nome): "Nic Raboy",

"senha": "8cb2237d0679ca88db6464eac60da96345513964",

"tipo": "usuário",

"uid":"c3e834b0-867e-4a43-aede-b15a4e139adc",

"nome de usuário": "nraboy"

}

]

Acima, fomos em frente e criamos uma sessão de usuário. Essa mesma estratégia também pode ser aplicada aos outros endpoints.

Conclusão

Usando o Node.js e o Couchbase Server SDK, você pode criar facilmente um backend de API para seus jogos. No Couchbase 4.0, agora você tem a liberdade de usar o N1QL como uma opção para consultar dados em seu aplicativo.

O aplicativo Node.js completo sobre o qual escrevemos neste artigo pode ser baixado gratuitamente no site GitHub do Couchbase Labs repositório.

Nic Raboy, defensor dos desenvolvedores, Couchbase

5 Comentários

Martin Micunda julho 18, 2015 em 3:52 pm

Hi,

Você ainda precisa habilitar o N1QL no couchbase 4 executando \'bucket.enableN1ql(\'localshot:8093\');\'? Obrigado pela atenção

Acesse para responder
1. Matt Ingenthron julho 18, 2015 em 6:12 pm
  
  Não, ele só funciona com o SDK mais recente
  
  Acesse para responder
  1. hubo julho 21, 2015 em 2:34 am
    
    Quero lhe pedir o erro de um cliente:\"
    
    [com.couchbase.client.deps.io.netty.util.ResourceLeakDetector] FUGA: ByteBuf.release() não foi chamado antes de ser coletado do lixo. Ative o relatório de vazamento avançado para descobrir onde ocorreu o vazamento. Para ativar o relatório de vazamento avançado, especifique a opção JVM \'-Dcom.couchbase.client.deps.io.netty.leakDetectionLevel=advanced\' ou chame ResourceLeakDetector.setLevel()\"
    Qual é o problema? Como resolvê-lo
    
    Acesse para responder
JMQ outubro 8, 2015 em 4:12 pm

Hi,

O N1QL só pode ser usado para consultas ou pode ser usado para fazer UPSERT\'s e INSERT\'s? Agradecimentos

Acesse para responder
1. Nic Raboy outubro 8, 2015 em 6:16 pm
  
  No momento, INSERT, UPDATE, DELETE e UPSERT são beta. Você pode usá-los, mas até que saiam da versão beta, não recomendamos usá-los em um ambiente de produção.
  
  http://developer.couchbase.com…
  
  Melhor,
  
  Acesse para responder

Deixar uma resposta Cancelar resposta

Você precisa fazer o login para publicar um comentário.

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

Criando um servidor de API de jogos usando o Node.js: Revisitado

Os pré-requisitos

Preparação do projeto

Preparando o banco de dados

Mac

Windows

Criação de um índice primário

A estrutura do projeto

O básico

O modelo de dados da API

O documento do usuário

O documento de nome de usuário

O documento da sessão

O documento do Estado

Criação do modelo de conta

Criação do modelo de sessão

Criação de uma sessão

Autenticação de um usuário

Criação do modelo de estado

Criação de um estado de salvamento

Obtendo os estados

Criação das rotas de API

Testando a API

Conclusão

Autor

Postado por Nic Raboy, defensor dos desenvolvedores, Couchbase

5 Comentários

Deixar uma resposta Cancelar resposta