Presentamos Camo: un ODM ES6 basado en clases para bases de datos similares a Mongo

¿Qué es Camo?

Camuflaje es un ODM ES6 con modelos basados ​​en clases. Algunas de sus características principales son: declaración de esquema completamente simple, herencia de esquema intuitiva y soporte para múltiples backends de base de datos.

Un modelo de Camo simple podría verse así:

var Document = require('camo').Document;

class Car extends Document {
	constructor() {
		super();

		this.make = String;
		this.miles = Number;
		this.numWheels = {
			type: Number;
			default: 4
		};
	}
}

Para instalar, solo use:

npm install camo --save

AND

npm install nedb --save
OR
npm install mongodb --save

¿Por qué otro ODM?

Por mucho que quisiera que me gustara Mongoose, como parecía que todos los demás, no podía aceptarlo. Puede haber sido porque todavía era nuevo en JavaScript, y no había abrazado el aspecto de programación funcional tanto como debería haberlo hecho, pero me quedé decepcionado con la forma en que se declararon los modelos y la falta de herencia de esquemas (o al menos sus torpeza).

Viniendo de un fondo de Java, me gustan mucho las clases. Así que diseñar modelos sin poder usar clases o herencia fácilmente fue difícil para mí. Como ES6 tiene soporte tradicional de clases y herencia, me sorprendió ver que ningún ODM de Node.js se basaba en clases.

Por último, me gustó cómo en SQL se puede cambiar fácilmente entre bases de datos pequeñas y portátiles como SQLite para el desarrollo y bases de datos más grandes y escalables como PostgreSQL para la producción. Viendo como NeDB llena muy bien ese vacío para MongoDB, quería un ODM que me permitiera cambiar fácilmente entre estas bases de datos.

Características

Clases

Como se mencionó anteriormente, Camo gira en torno a las clases ES6 para crear modelos. Cada modelo debe extender el Document clase, la EmbeddedDocument clase, u otro modelo. Los esquemas se declaran en los constructores, donde puede especificar el tipo de datos, valores predeterminados, opciones y otros validadores.

Se pueden usar virtuales, métodos y estática para manipular y recuperar los datos del modelo, como una clase normal no persistente.

var Document = require('camo').Document;

class Manufacturer extends Document {
	constructor() {
		super();

		this.name = String;
	}
}

class Car extends Document {
	constructor() {
		super();

		this.make = Manufacturer;
		this.model = String;
		this.year = {
			type: Number,
			min: 1900,
			max: 2015
		};
		this.miles = {
			type: Number,
			min: 0
		};
		this.numWheels = {
			type: Number;
			default: 4
		};
	}

	get isUnderWarranty() {
		return this.miles < 50000;
	}

	milesPerYear() {
		return this.miles / (new Date().getFullYear() - this.year)
	};
}

Documentos incrustados

Una de las principales ventajas de usar MongoDB es su estructura de datos anidada, y debería poder aprovecharla fácilmente en su ODM. Camo tiene soporte integrado para documentos incorporado, por lo que puede tratar los datos de los documentos anidados como lo haría con un documento normal.

var Document = require('camo').Document;
var EmbeddedDocument = require('camo').EmbeddedDocument;

class Warranty extends EmbeddedDocument {
	constructor() {
		super();

		this.miles = Number;
		this.years = Number;
		this.isUnlimitedMiles = Boolean;
	}

	isCovered(car) {
		var thisYear = new Date().getFullYear();
		return ((car.miles <= this.miles) || this.isUnlimitedMiles) &&
			((thisYear - car.year) <= this.years)
	};
}

class Manufacturer extends Document {
	constructor() {
		super();

		this.name = String;

		this.basicWarranty = Warranty;
		this.powertrainWarranty = Warranty;
		this.corrosionWarranty = Warranty;
	}
}

Soporte de múltiples bases de datos

No todos los proyectos requieren una base de datos enorme con replicación, equilibrio de carga y soporte para millones de lecturas / escrituras por segundo, que es exactamente la razón por la que era importante para Camo admitir múltiples backends de bases de datos, como NeDB.

La mayoría de los proyectos comienzan siendo pequeños y eventualmente se convierten en productos más grandes y populares que requieren bases de datos más rápidas y sólidas. Con NeDB, obtiene un subconjunto de los comandos API de MongoDB más utilizados sin la necesidad de configurar la base de datos completa. Es como tener el equivalente de SQLite, pero para Mongo. Para cambiar entre las bases de datos, simplemente proporcione una cadena de conexión diferente.

var connect = require('camo').connect;

var uri;
var neUri = 'nedb://memory';
var mongoUri = 'mongodb://localhost/car-app';

uri = neUri;
if (process.env.NODE_ENV === 'production') {
	uri = mongoUri;
}

connect(uri).then(function(db) {
	// Ready to use Camo!
});

A partir de la versión 0.5.5, Camo es compatible con MongoDB y NeDB. Estamos planeando agregar soporte para más bases de datos similares a Mongo, incluyendo LokiJSy TaffyDB. Con NeDB y las adiciones de LokiJS y TaffyDB, también puede usar Camo en el navegador.

Herencia

Podría decirse que una de las mejores características de Camo es la herencia de esquemas. Simplemente use la herencia de clases ES6 para extender un esquema.

var Document = require('camo').Document;

class Vehicle extends Document {
	constructor() {
		super();

		this.make = String;
		this.model = String;
		this.year = Number;
		this.miles = Number;
	}
}

class Car extends Vehicle {
	constructor() {
		super();

		this.numberOfDoors = String;
	}
}

Las subclases pueden anular o ampliar cualquier esquema, virtual, método o estática, lo que da como resultado un código más legible y más simple.

¿Camo está listo para la producción?

Si bien Camo ya tiene bastantes funciones y solo algunos errores conocidos, todavía es un trabajo en progreso. Aquí hay una breve lista de las características principales que aún queremos agregar al proyecto antes de declarar v1.0:

• Devolver un Query objeto de findOne / buscar / eliminar / etc
• Agregue soporte para omitir / limitar a las consultas
• Agregue una opción para completar solo las referencias especificadas
• Agregue soporte para LokiJS y TaffyDB

Dicho esto, Camo ya se está utilizando en el código de producción en Polimetría (un SaaS que proporciona métricas para Stripe). El código base para Polymetrics se creó originalmente en Mongoose, pero luego se reemplazó con Camo sin ningún problema. Las pruebas y el desarrollo son mucho más fáciles ahora que podemos cambiar fácilmente entre bases de datos.

Camo también facilitó mucho el diseño de los modelos para Polymetrics. Gran parte de los datos que necesitamos descargar y guardar de Stripe tienen los mismos campos (como fechas, metadatos, etc.), por lo que extender un esquema común nos permitió escribir menos código, además de permitirnos solo tener que cambiar la base. esquema en lugar de tener que realizar el mismo cambio en muchos archivos.

Conclusión

Dirígete al npm o Github páginas y ver el proyecto. El README es actualmente la mejor fuente de documentación., así que si falta algo, hágamelo saber.

Como siempre, cualquier sugerencia, pregunta, comentario o solicitud de extracción es bienvenida. No dude en ponerse en contacto conmigo a través de Gorjeo, Github, o correo electrónico.