Using PouchDB and Couchbase NoSQL in Your Node.js Web Application

Una de mis tecnologías preferidas para desarrollar aplicaciones web es Node.js. Hago mucho desarrollo en JavaScript, así que es otra pieza que encaja en mi puzzle de desarrollo. No hace mucho escribí una guía para usando Couchbase Mobile y el SDK de Couchbase Node.js en la misma pila. En ese artículo había mencionado que hay varias maneras diferentes de llevar a cabo esta tarea. Me imaginé que iba a elaborar en otra forma de hacer el trabajo, esta vez usando PouchDB.

PouchDB es una base de datos JavaScript que funciona en combinación con Couchbase Sync Gateway y Couchbase Server. Al ser JavaScript, puedes usarlo en tus aplicaciones basadas en servidor y navegador.

Requisitos

Dado que se trata de una aplicación JavaScript no habrá muchas dependencias de software. Las pocas que existen son las siguientes:

Node.js 4.0+
Pasarela de sincronización Couchbase

Esta es una aplicación Node.js, pero el Node Package Manager (NPM) es lo que hará la mayor parte del trabajo pesado cuando se trata de preparar nuestro proyecto. Obtendrá PouchDB y el resto de dependencias. Usaremos el Couchbase Sync Gateway base de datos en memoria porque esto es sólo una aplicación de ejemplo. En producción, querrás conectar Sync Gateway a Couchbase Server para el almacenamiento persistente.

Configuración de Couchbase Sync Gateway para la sincronización de datos

Sync Gateway manejará todos nuestros datos remotos antes y después de que lleguen a Couchbase Server. Es nuestro servicio intermediario que orquestará los datos entre plataformas, dispositivos, etc. No es un requisito para construir aplicaciones Node.js que funcionen con Couchbase Server. Lo usamos porque también queremos soportar sincronización móvil, aunque no se demostrará en este ejemplo.

Con Couchbase Sync Gateway descargado e instalado, necesitamos establecer una configuración para cargar en tiempo de ejecución. Crea un archivo llamado sync-gateway-config.json e incluyen lo siguiente:

{
    "log":["CRUD+", "REST+", "Changes+", "Attach+"],
    "databases": {
        "example": {
            "server":"walrus:",
            "sync":`
                function (doc) {
                    channel (doc.channels);
                }
            `,
            "users": {
                "GUEST": {
                    "disabled": false,
                    "admin_channels": ["*"]
                }
            }
        }
    },
    "CORS": {
        "Origin": ["http://localhost:3000"],
        "LoginOrigin": ["http://localhost:3000"],
        "Headers": ["Content-Type"],
        "MaxAge": 17280000
    }
}

{

"log":["CRUD+", "REST+", "Cambios+", "Adjuntar+"],

"bases de datos": {

"ejemplo": {

"servidor":"morsa:",

"sync":`

función (doc) {

canal (doc.canales);

}

"usuarios": {

"INVITADO": {

"desactivado": falso,

"admin_canales": ["*"]

}

"CORS": {

"Origen": ["http://localhost:3000"],

"LoginOrigin": ["http://localhost:3000"],

"Cabeceras": ["Tipo de contenido"],

"MaxAge": 17280000

}

En el archivo de configuración básico anterior establecemos una base de datos llamada ejemplo que utiliza la opción de almacenamiento en memoria de Sync Gateway. No hay permisos específicos de lectura o escritura en esta configuración, lo que significa que todos los datos existirán en el mismo canal.

Debido a que estamos ejecutando Sync Gateway y nuestro ejemplo Node.js que pronto será creado en la misma máquina, pero diferentes puertos, tenemos que permitir el uso compartido de recursos de origen cruzado (CORS). Si no lo hacemos, terminaremos con errores relacionados con JavaScript. En la configuración anterior estamos diciendo que queremos permitir la comunicación desde http://localhost:3000, que es nuestra aplicación Node.js.

En este punto puede ejecutarse Sync Gateway. En un entorno de producción, el servidor en memoria morsa puede sustituirse por el nombre de host de un clúster de Couchbase Server concreto.

Desarrollo de la aplicación web Node.js

Para hacer las cosas fáciles de entender, vamos a crear una aplicación Node.js fresca y trabajar nuestro camino hacia arriba. Esto se puede hacer utilizando el gestor de paquetes de Node.

Desde el Símbolo del sistema o Terminal, ejecute lo siguiente:

npm init --y

1	npm init --y

El comando anterior creará un paquete.json que mantendrá todas las dependencias de nuestro proyecto. Con el archivo paquete.json en su lugar, vamos a obtener algunas dependencias:

npm install express body-parser pouchdb --save

1	npm instale express cuerpo-analizador pouchdb --guardar

El comando anterior instalará Express Framework, un paquete necesario para gestionar los datos del cuerpo de las peticiones, y PouchDB para gestionar los datos de nuestra aplicación.

Antes de empezar a escribir código, tenemos que crear un archivo llamado app.js que contendrá toda la lógica de nuestra aplicación.

Puesta en marcha de la API RESTful

Con el app.js creado, ábralo e incluya el siguiente código JavaScript:

var Express = require("express");
var BodyParser = require("body-parser");
var PouchDB = require("pouchdb");

var app = Express();

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

var database = new PouchDB("http://192.168.57.1:4984/example");

app.get("/people", function(req, res) { });

app.get("/people/:id", function(req, res) { });

app.post("/people", function(req, res) { });

app.delete("/people", function(req, res) { });

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

var Express = requiere("express");

var BodyParser = requiere("body-parser");

var PouchDB = requiere("pouchdb");

var aplicación = Express();

aplicación.utilice(BodyParser.json());

aplicación.utilice(BodyParser.urlencoded({ ampliado: verdadero }));

var base de datos = nuevo PouchDB("http://192.168.57.1:4984/example");

aplicación.consiga("/gente", función(consulte, res) { });

aplicación.consiga("/personas/:id", función(consulte, res) { });

aplicación.Correo electrónico:("/gente", función(consulte, res) { });

aplicación.borrar("/gente", función(consulte, res) { });

var servidor = aplicación.escuche(3000, función() {

base de datos.información().entonces(función(información) {

consola.registro(información);

consola.registro("Escuchando en el puerto %s...", servidor.dirección().puerto);

});

Entonces, ¿qué está pasando en el código anterior? En primer lugar estamos importando las dependencias que fueron instaladas previamente y las estamos inicializando.

Debido a que esta es una aplicación del lado del servidor tenemos dos opciones cuando se trata de utilizar PouchDB. Podríamos crear una base de datos local en nuestro servidor de aplicaciones que se sincroniza con Sync Gateway o podemos conectarnos a la instancia de Sync Gateway directamente.

var database = new PouchDB("http://192.168.57.1:4984/example");

1	var base de datos = nuevo PouchDB("http://192.168.57.1:4984/example");

Lo anterior indica que vamos a conectarnos directamente a nuestro servidor Sync Gateway que se ejecuta localmente. Puede elegir la opción de sincronización si desea adoptar un enfoque diferente en el equilibrio de carga.

app.get("/people", function(req, res) { });
app.get("/people/:id", function(req, res) { });
app.post("/people", function(req, res) { });
app.delete("/people", function(req, res) { });

aplicación.consiga("/gente", función(consulte, res) { });

aplicación.consiga("/personas/:id", función(consulte, res) { });

aplicación.Correo electrónico:("/gente", función(consulte, res) { });

aplicación.borrar("/gente", función(consulte, res) { });

Vamos a construir una API RESTful que utiliza CRUD, pero por ahora tiene sentido definir cada uno de los puntos finales que deseamos utilizar en Express Framework.

Por último, definimos cómo queremos servir la aplicación:

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

var servidor = aplicación.escuche(3000, función() {

base de datos.información().entonces(función(información) {

consola.registro(información);

consola.registro("Escuchando en el puerto %s...", servidor.dirección().puerto);

});

Vamos a servir la aplicación en http://localhost:3000 y cuando el servidor arranque imprimiremos información relativa a PouchDB. Nos servirá para hacernos una idea sobre la conexión y los datos que existen.

Incluida la lógica de manipulación de datos de PouchDB

Con la aplicación arrancada, podemos empezar a aplicar la lógica de la aplicación a cada uno de los métodos del endpoint. Comenzando con el punto final de la lista, tenemos lo siguiente:

app.get("/people", function(req, res) {
    database.allDocs({include_docs: true}).then(function(result) {
        res.send(result.rows.map(function(item) {
            return item.doc;
        }));
    }, function(error) {
        res.status(400).send(error);
    });
});

aplicación.consiga("/gente", función(consulte, res) {

base de datos.allDocs({incluir_docs: verdadero}).entonces(función(resultado) {

res.enviar(resultado.filas.mapa(función(artículo) {

devolver artículo.doc;

}));

}, función(error) {

res.estado(400).enviar(error);

});

Cuando el endpoint es alcanzado, consultaremos todos los documentos e incluiremos las propiedades del documento en los resultados. Para omitir información que podría no sernos útil podemos mapear la respuesta antes de devolverla, de lo contrario podemos devolver un error.

En lugar de listar todos los documentos podemos querer obtener un único documento.

app.get("/people/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An `id` is required"});
    }
    database.get(req.params.id).then(function(result) {
        res.send(result);
    }, function(error) {
        res.status(400).send(error);
    });
});

aplicación.consiga("/personas/:id", función(consulte, res) {

si(!consulte.parámetros.id) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `id`"});

}

base de datos.consiga(consulte.parámetros.id).entonces(función(resultado) {

res.enviar(resultado);

}, función(error) {

res.estado(400).enviar(error);

});

En el escenario anterior esperamos que se incluya un id de documento en la petición. Si el id existe intentaremos obtener un documento y devolvérselo al solicitante, de lo contrario devolveremos un error.

¿Y la creación de nuevos documentos?

Para crear documentos dentro de Couchbase, haríamos algo como lo siguiente:

app.post("/people", function(req, res) {
    if(!req.body.firstname) {
        return res.status(400).send({"status": "error", "message": "A `firstname` is required"});
    } else if(!req.body.lastname) {
        return res.status(400).send({"status": "error", "message": "A `lastname` is required"});
    }
    database.post(req.body).then(function(result) {
        res.send(result);
    }, function(error) {
        res.status(400).send(error);
    });
});

aplicación.Correo electrónico:("/gente", función(consulte, res) {

si(!consulte.cuerpo.nombre) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `nombre`"});

} si no si(!consulte.cuerpo.apellido) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `apellido`"});

}

base de datos.Correo electrónico:(consulte.cuerpo).entonces(función(resultado) {

res.enviar(resultado);

}, función(error) {

res.estado(400).enviar(error);

});

En el código anterior esperamos un nombre y un apellido exista. Si esto es cierto, crearemos el documento usando todo el cuerpo de la entrada y devolveremos la respuesta. No tenemos que usar todo el cuerpo de la entrada, pero en este ejemplo sí. Tenga en cuenta que esto sólo creará un documento, no actualizará el documento. La actualización de los documentos utilizaría un poner en lugar de un método Correo electrónico: método.

La parte final de nuestra aplicación es el punto final para borrar datos.

app.delete("/people", function(req, res) {
    if(!req.body.id) {
        return res.status(400).send({"status": "error", "message": "An `id` is required"});
    }
    database.get(req.body.id).then(function(result) {
        return database.remove(result);
    }).then(function(result) {
        res.send(result);
    }, function(error) {
        res.status(400).send(error);
    });
});

aplicación.borrar("/gente", función(consulte, res) {

si(!consulte.cuerpo.id) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `id`"});

}

base de datos.consiga(consulte.cuerpo.id).entonces(función(resultado) {

devolver base de datos.eliminar(resultado);

}).entonces(función(resultado) {

res.enviar(resultado);

}, función(error) {

res.estado(400).enviar(error);

});

Esperamos que se introduzca un identificador en la solicitud. Si este id existe, primero hacemos una búsqueda para asegurarnos de que el documento existe. Si el documento existe, podemos borrarlo. Todo esto se logra encadenando promesas JavaScript.

Probar el código fuente del proyecto terminado

Si quieres tener una idea más clara de cómo es esta aplicación, a continuación puedes ver el código completo.

var Express = require("express");
var BodyParser = require("body-parser");
var PouchDB = require("pouchdb");

var app = Express();

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

var database = new PouchDB("http://192.168.57.1:4984/example");

app.get("/people", function(req, res) {
    database.allDocs({include_docs: true}).then(function(result) {
        res.send(result.rows.map(function(item) {
            return item.doc;
        }));
    }, function(error) {
        res.status(400).send(error);
    });
});

app.get("/people/:id", function(req, res) {
    if(!req.params.id) {
        return res.status(400).send({"status": "error", "message": "An `id` is required"});
    }
    database.get(req.params.id).then(function(result) {
        res.send(result);
    }, function(error) {
        res.status(400).send(error);
    });
});

app.post("/people", function(req, res) {
    if(!req.body.firstname) {
        return res.status(400).send({"status": "error", "message": "A `firstname` is required"});
    } else if(!req.body.lastname) {
        return res.status(400).send({"status": "error", "message": "A `lastname` is required"});
    }
    database.post(req.body).then(function(result) {
        res.send(result);
    }, function(error) {
        res.status(400).send(error);
    });
});

app.delete("/people", function(req, res) {
    if(!req.body.id) {
        return res.status(400).send({"status": "error", "message": "An `id` is required"});
    }
    database.get(req.body.id).then(function(result) {
        return database.remove(result);
    }).then(function(result) {
        res.send(result);
    }, function(error) {
        res.status(400).send(error);
    });
});

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

var Express = requiere("express");

var BodyParser = requiere("body-parser");

var PouchDB = requiere("pouchdb");

var aplicación = Express();

aplicación.utilice(BodyParser.json());

aplicación.utilice(BodyParser.urlencoded({ ampliado: verdadero }));

var base de datos = nuevo PouchDB("http://192.168.57.1:4984/example");

aplicación.consiga("/gente", función(consulte, res) {

base de datos.allDocs({incluir_docs: verdadero}).entonces(función(resultado) {

res.enviar(resultado.filas.mapa(función(artículo) {

devolver artículo.doc;

}));

}, función(error) {

res.estado(400).enviar(error);

});

aplicación.consiga("/personas/:id", función(consulte, res) {

si(!consulte.parámetros.id) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `id`"});

}

base de datos.consiga(consulte.parámetros.id).entonces(función(resultado) {

res.enviar(resultado);

}, función(error) {

res.estado(400).enviar(error);

});

aplicación.Correo electrónico:("/gente", función(consulte, res) {

si(!consulte.cuerpo.nombre) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `nombre`"});

} si no si(!consulte.cuerpo.apellido) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `apellido`"});

}

base de datos.Correo electrónico:(consulte.cuerpo).entonces(función(resultado) {

res.enviar(resultado);

}, función(error) {

res.estado(400).enviar(error);

});

aplicación.borrar("/gente", función(consulte, res) {

si(!consulte.cuerpo.id) {

devolver res.estado(400).enviar({"status": "error", "mensaje": "Se requiere un `id`"});

}

base de datos.consiga(consulte.cuerpo.id).entonces(función(resultado) {

devolver base de datos.eliminar(resultado);

}).entonces(función(resultado) {

res.enviar(resultado);

}, función(error) {

res.estado(400).enviar(error);

});

var servidor = aplicación.escuche(3000, función() {

base de datos.información().entonces(función(información) {

consola.registro(información);

consola.registro("Escuchando en el puerto %s...", servidor.dirección().puerto);

});

Para ejecutar la aplicación debe ejecutar node app.js desde tu Terminal o Command Prompt y luego pulsa los endpoints de http://localhost:3000 desde cURL o la aplicación que prefieras.

Conclusión

Acabas de ver cómo incluir PouchDB en una aplicación web Node.js del lado del servidor donde PouchDB se comunica con una base de datos NoSQL Couchbase. Este fue uno de los muchos ejemplos diferentes de cómo puedes incluir móvil y servidor en la misma pila porque Sync Gateway está sentado en el medio. En una entrada anterior Escribí sobre el uso de la API RESTful de Sync Gateway en lugar de PouchDB. Ese ejemplo también demostró el uso móvil y de servidor con Couchbase.

Nic Raboy, Defensor del Desarrollador, 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

Todos los mensajes

Uso de PouchDB y Couchbase NoSQL en tu aplicación web Node.js

Requisitos

Configuración de Couchbase Sync Gateway para la sincronización de datos

Desarrollo de la aplicación web Node.js

Puesta en marcha de la API RESTful

Incluida la lógica de manipulación de datos de PouchDB

Probar el código fuente del proyecto terminado

Conclusión

Autor

Publicado por Nic Raboy, Defensor del Desarrollador, Couchbase

Dejar una respuesta Cancelar respuesta