Primeros pasos con camuflaje

Editar: Código actualizado a Camo v0.12.1 En primer lugar, Camo es un nuevo ODM ES6 basado en clases para MongoDB y Node. Con ES6 estándar acercándose rápidamente a nosotros, pensé...

Editar: Código actualizado a Camo v0.12.1

Introducción

En primer lugar, camuflaje es un nuevo ODM ES6 basado en clases para MongoDB y Node. Con ES6 estándar acercándose rápidamente a nosotros, pensé que hacía mucho tiempo que hacía falta un ODM que aprovechara las nuevas funciones, así que creé Camo. Lo que más me molestó al pasar de la programación Java a JavaScript fue la falta de clases de estilo tradicional. Creo que especialmente para los principiantes, esta es una característica importante para cualquier ODM.

En este tutorial, le mostraré cómo usar las funciones básicas de Camo (declaración de esquema, guardado, carga, etc.). Para facilitar las comparaciones con Mongoose, mostraré ejemplos similares al artículo Primeros pasos con la mangosta. Con suerte, desde aquí puede decidir qué estilo/funcionalidad le gusta más para usar en sus proyectos.

Conectando Camo a MongoDB

Nota: El código de este artículo usa v0.12.1 de Camo.

Para conectar Camo a su base de datos, simplemente pase la cadena de conexión (normalmente con el formato mongodb://[dirección IP]/[nombre-bd]) al método connect(), que devolverá una instancia de el cliente Camo. La instancia del cliente se puede usar para configurar la base de datos, pero no es necesaria para declarar, guardar o eliminar sus documentos.

1
2
3
4
5
6
7
var connect = require('camo').connect;
 
var database;
var uri = 'mongodb://localhost/test';
connect(uri).then(function(db) {
    database = db;
});

Esquemas y modelos

Los modelos están declarados usando clases ES6 y deben extender el objeto Document. El esquema del modelo se declara dentro del constructor, y cualquier variable miembro que no comience con un guión bajo (_) se incluye en el esquema y se guarda en la base de datos. Una variable miembro se puede declarar asignándole directamente un tipo o asignándole un objeto con opciones.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
var Document = require('camo').Document;
 
class Movie extends Document {
    constructor() {
        super();

        this.title = String;
        this.rating = {
            type: String,
            choices: ['G', 'PG', 'PG-13', 'R']
        };
        this.releaseDate = Date;
        this.hasCreditCookie = Boolean;
    }

    static collectionName() {
        return 'movies';
    }
}

El nombre de la colección se declara anulando el método estático collectionName(). Aunque este nombre rara vez se necesita en el código, será útil cuando se inspeccione la base de datos MongoDB manualmente, por lo que es mejor mantenerlo relevante para el nombre del modelo.

Si no se proporciona nombre_colección(), Camo asignará automáticamente un nombre de colección basado en el nombre de la clase.

Crear, recuperar, actualizar y eliminar (CRUD)

Para crear una instancia del modelo, solo use el método create(), que maneja gran parte del trabajo de creación de instancias por usted. Opcionalmente, los datos se pueden pasar a create() que se asignarán a las variables miembro. Si no se pasan datos para una variable, se le asigna un valor predeterminado (si se especifica en el esquema) o se le asigna un valor nulo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
var thor = Movie.create({
    title: 'Thor',
    rating: 'PG-13',
    releaseDate: new Date(2011, 4, 2),
    hasCreditCookie: true
});

thor.save().then(function(t) {
    console.log(thor);
});

Cuando ahorro la instancia, los datos se insertarán en la base de datos si no se han guardado previamente. Si la instancia ya se ha guardado en la base de datos, el documento existente se actualiza con los cambios.

Para Eliminar un documento, simplemente llame al método delete en él. También puede utilizar deleteOne(), deleteMany() o findOneAndDelete() estáticos en la clase modelo. La cantidad de documentos eliminados de la base de datos se devolverá dentro de la Promesa.

1
2
3
thor.delete().then(function(numDeleted) {
    console.log(numDeleted);
});

Para cargar un documento de la base de datos, tiene algunas opciones dependiendo de lo que quiera hacer. Las opciones son:

  • findOne() para cargar un solo documento (o nulo si no existe)
1
2
3
4
// Load only the 'Thor' movie
Movie.findOne({ title: 'Thor' }).then(function(movie) {
    console.log(thor);
});
  • find() para cargar varios documentos (o una matriz vacía si no existe)
1
2
3
4
// Load all movies that have a credit cookie
Movie.find({ hasCreditCookie: true }).then(function(movies) {
    console.log(thor);
});
  • findOneAndUpdate() para recuperar un documento y actualizarlo en una sola operación atómica
1
2
3
4
// Update 'Thor' to have a rating of 'R'
Movie.findOneAndUpdate({ title: 'Thor' }, { rating: 'R' }).then(function(movies) {
    console.log(thor);
});

Extras

Gracias a la compatibilidad de Camo con las clases ES6, podemos definir fácilmente estáticas, virtuales y métodos para los modelos, lo que hace que el código del modelo sea mucho más organizado y legible.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
var Document = require('camo').Document;
 
class Movie extends Document {
    constructor() {
        super();

        // Schema declaration here...
    }

    set releaseYear(year) {
        this.releaseDate.setYear(year);
    }

    get releaseYear() {
        return this.releaseDate.getFullYear();
    }

    yearsOld() {
        return new Date().getFullYear() - this.releaseDate.getFullYear();
    }

    static findAllRMovies() {
        return this.find({ rating: 'R' });
    }
}

var uri = 'nedb://memory';

connect(uri).then(function(db) {
    var thor = Movie.create({
        title: 'The Matrix',
        rating: 'R',
        releaseDate: new Date(1999, 2, 31),
        hasCreditCookie: true
    });
    
    return thor.save();
}).then(function(t) {
    return Movie.findAllRMovies();
}).then(function(movies) {
    movies.forEach(function(m) {
        console.log(m.title + ': ' + m.releaseDate.getFullYear());
    });
});

Además de interactuar con MongoDB, Camo también es compatible con NeDB, que es como el equivalente de SQLite a Mongo. Arriba se muestra un ejemplo del uso de NeDB. Es muy útil usarlo durante el desarrollo y las pruebas, ya que los datos se pueden almacenar en un archivo o solo en la memoria. ¡Esto también significa que puede usar Camo en el código del navegador frontal!

Dirígete a la página del proyecto para obtener más información. ¿Te gusta lo que ves? ¡Empieza el proyecto y corre la voz!