DataOrbit - Base de datos JSON con cifrado para Node.js

Una potente base de datos NoSQL basada en JSON para Node.js con cifrado incorporado, ideal para aplicaciones pequeñas y medianas que requieren persistencia de datos sin la complejidad de una base de datos completa.

Características

• 🔒 Cifrado integrado - Todos los datos se cifran automáticamente
• 📊 API similar a MongoDB - Consultas, índices y operaciones CRUD familiares
• 🔍 Sistema de índices - Búsquedas optimizadas con índices
• 🧪 Validación de esquemas - Definición de tipos y restricciones
• 🔄 Transacciones - Operaciones atómicas con rollback automático
• 📦 Backup y restauración - Gestión de copias de seguridad programadas
• 📋 Operaciones avanzadas - Agregaciones, filtros y proyecciones

Instalación

npm install data-orbit-node --save

Uso básico

const { DataOrbit, DataType } = require('data-orbit-node');

// Configuración de la base de datos
const db = new DataOrbit({
  file: './mibasededatos.json',
  encryptionKey: 'mi-clave-secreta',
  tables: {
    usuarios: {
      primaryKey: 'id',
      unique: ['email'],
      schema: {
        nombre: { type: DataType.TEXT, required: true },
        email: { type: DataType.TEXT, required: true },
        edad: { type: DataType.NUMBER }
      }
    }
  }
});

// Insertar un registro
const usuario = db.insert('usuarios', {
  nombre: 'Juan Pérez',
  email: '[email protected]',
  edad: 30
});

console.log('Usuario insertado:', usuario);

// Buscar registros
const usuarios = db.find('usuarios', { edad: { $gt: 25 } });
console.log('Usuarios mayores de 25:', usuarios);

Guía completa

Configuración

Para crear una instancia de DataOrbit, necesitas proporcionar una configuración:

const db = new DataOrbit({
  // Ruta al archivo JSON (obligatorio)
  file: './database.json',

  // Clave de cifrado para proteger los datos (obligatorio)
  encryptionKey: 'clave-secreta',

  // Definición de tablas (opcional pero recomendado)
  tables: {
    tabla1: {
      // Clave primaria (por defecto es 'id')
      primaryKey: 'id',

      // Campos con restricción de unicidad
      unique: ['campo1', 'campo2'], 

      // Esquema de validación
      schema: {
        campo1: { type: DataType.TEXT, required: true },
        campo2: { type: DataType.NUMBER, required: false },
        // ...más campos
      }
    },
    // ...más tablas
  },

  // Configuración de backups automáticos (opcional)
  backups: [
    { interval: 1 } // Backup diario (cada 1 día)
  ]
});

Tipos de datos

DataOrbit soporta los siguientes tipos de datos:

const { DataType } = require('data-orbit-node');

// Tipos disponibles
DataType.TEXT    // Texto
DataType.NUMBER  // Número
DataType.BOOLEAN // Booleano
DataType.DATE    // Fecha
DataType.OBJECT  // Objeto
DataType.ARRAY   // Array
DataType.PATH    // Ruta de archivo (con validación de existencia)

Operaciones CRUD

Crear tablas

// Crear una tabla con esquema
db.createTable('productos', {
  nombre: { type: DataType.TEXT, required: true },
  precio: { type: DataType.NUMBER, required: true },
  disponible: { type: DataType.BOOLEAN, required: true }
});

Insertar documentos

// Insertar un documento
const producto = db.insert('productos', {
  nombre: 'Smartphone XYZ',
  precio: 599.99,
  disponible: true
});

console.log('ID del producto:', producto.id);

Buscar documentos

// Encontrar todos los documentos
const todosProductos = db.findAll('productos');

// Buscar por coincidencia exacta
const disponibles = db.find('productos', { disponible: true });

// Buscar por ID
const producto = db.findById('productos', 1);

// Buscar el primer documento que coincida
const primerProducto = db.findOne('productos', { precio: { $lt: 100 } });

Actualizar documentos

// Actualizar un documento por ID
const actualizado = db.update('productos', 1, { 
  precio: 499.99, 
  disponible: false 
});

console.log('Producto actualizado:', actualizado);

Eliminar documentos

// Eliminar un documento por ID
const eliminado = db.delete('productos', 1);
console.log('Producto eliminado:', eliminado);

Consultas avanzadas

DataOrbit soporta operadores de consulta similares a MongoDB:

// Operadores de comparación
const productos = db.find('productos', {
  precio: { $gt: 100 },    // Mayor que
  stock: { $gte: 10 },     // Mayor o igual que
  descuento: { $lt: 50 },  // Menor que
  peso: { $lte: 1 },       // Menor o igual que
  color: { $ne: 'rojo' },  // Diferente de
  categoria: { $in: ['electrónica', 'móviles'] }, // En el array
  marca: { $nin: ['marca1', 'marca2'] } // No en el array
});

Agregaciones

// Pipeline de agregación
const resultado = db.aggregate('ventas', [
  // Etapa de filtrado
  { $match: { fecha: { $gt: '2023-01-01' } } },

  // Etapa de proyección (selección de campos)
  { $project: { producto: 1, cantidad: 1, total: 1 } },

  // Etapa de agrupación
  { $group: {
    _id: "$producto",
    totalVendidos: { $sum: "$cantidad" },
    valorTotal: { $sum: "$total" },
    ventaPromedio: { $avg: "$total" },
    ventaMinima: { $min: "$total" },
    ventaMaxima: { $max: "$total" },
    todasLasVentas: { $push: "$total" }
  }},

  // Etapa de ordenamiento
  { $sort: { valorTotal: -1 } },

  // Etapa de límite
  { $limit: 5 }
]);

Transacciones

// Ejecutar operaciones en una transacción
db.transaction(database => {
  // Si ocurre algún error, todas las operaciones se revierten
  const producto = database.findById('productos', 1);

  if (producto.stock < 10) {
    throw new Error('Stock insuficiente');
  }

  database.update('productos', 1, { stock: producto.stock - 1 });

  database.insert('ventas', {
    producto: producto.id,
    cantidad: 1,
    total: producto.precio
  });

  return 'Venta completada';
});

Índices

// Crear un índice para búsquedas rápidas
db.createIndex('productos', 'categoria');

// Eliminar un índice
db.dropIndex('productos', 'categoria');

Backups y restauración

// Crear un backup manual
const rutaBackup = db.backup();
console.log('Backup creado en:', rutaBackup);

// Restaurar desde un backup
db.restore('./backups/mibasededatos_2023-04-12.json');

Importación y exportación

// Exportar datos a un archivo JSON
db.exportToJson('./export/datos.json', {
  tables: ['usuarios', 'productos'], // Opcional: tablas específicas
  excludeMetadata: true              // Opcional: excluir metadatos
});

// Importar datos desde un archivo JSON
db.importFromJson('./import/datos.json', {
  mode: 'merge',     // 'merge' o 'replace'
  overwrite: true    // Sobrescribir registros existentes
});

Estadísticas

// Obtener estadísticas de la base de datos
const stats = db.stats();
console.log('Documentos totales:', stats.totalDocuments);
console.log('Tamaño de la base de datos:', stats.databaseSize, 'bytes');
console.log('Tablas:', Object.keys(stats.tables));

Gestión avanzada

Reconstruir índices

Si los datos se modifican externamente o se sospecha inconsistencia en los índices:

// Recargar la base de datos y reconstruir índices
db.loadDatabase();

Reiniciar la base de datos

// Eliminar todos los datos (se crea un backup automáticamente)
db.reset();

Buenas prácticas

1. Seguridad de la clave de cifrado: Guarda la clave de cifrado en variables de entorno, no en el código.
2. Backups regulares: Configura backups automáticos y realiza backups manuales antes de operaciones importantes.
3. Esquemas: Define siempre esquemas para validar los datos y mantener la consistencia.
4. Índices: Crea índices para los campos que se utilizan frecuentemente en búsquedas.
5. Transacciones: Usa transacciones para operaciones que impliquen múltiples cambios relacionados.

Limitaciones

• No recomendado para bases de datos muy grandes (>100MB) debido a la carga completa en memoria.
• No es adecuado para entornos con múltiples procesos escribiendo simultáneamente.
• El archivo completo se sobrescribe en cada operación de guardado.

Contribuir

Las contribuciones son bienvenidas. Por favor, abre un issue o pull request en el repositorio GitHub.

Licencia

Este proyecto está licenciado bajo la Licencia MIT.