Options
All
  • Public
  • Public/Protected
  • All
Menu

camadb

CamaDB

CamaDB is a NoSQL embedded database written in pure TypeScript for Node, Electron and browser-based environments.

semantic-release

Why?

I was struggling to find a solution for Electron-based projects that deal with larger datasets in the main thread.

  • I had issues getting SQLite to work with webpack due to its native build
  • SQLite doesn't (by default) return native JS data types (Dates in particular)
  • Other NoSQL embedded databases seem to be largely abandoned
  • Most other NoSQL embedded databases seem to be limited by V8's hard string length limits

Goals

  • Fast querying/insertion/manipulation of data, up to 1 million rows
  • Frictionless integration with all JS runtimes
  • Rich API
  • Full TypeScript support
  • Simplicity and versatility - This is built for storing data in dynamic structures

Current state

This is still under active development and a few features are missing:

  • Indexes - We're finding that this is fast even without these, but every little helps
  • Rich text search

Getting started

Documentation

Installing

yarn add reflect-metadata
yarn add camadb

OR

npm install reflect-metadata --save
npm install camadb --save

Initializing the database

All of these config options are optional:

  • path - Where you want the data to be stored - default is ./.cama or cama for indexeddb and localstorage
  • persistenceAdapter - How you want to persist your data - fs, indexeddb, localstorage or inmemory
  • logLevel - info or debug
    import { Cama } from 'camadb'
    const database = new Cama({
    path: './.cama',
    persistenceAdapter: 'fs',
    logLevel: 'debug'
    });

Initializing a collection

  • Use the columns field to add specific data types for rows. This does need to be done for each column, but is essential for date objects
  • Indexes aren't currently implemented, but the lookup is still very fast across 10 million rows
     const collection = await database.initCollection('test', {
    columns: [{
    type:'date',
    title:'date'
    }],
    indexes: [],
    });

Insert one

 await collection.insertOne({
_id: 'test',
name: 'Dummy field',
description: `Data`,
});

Insert many

  await collection.insertMany([{
_id: 'test',
name: 'Dummy field',
description: `Data`,
}]);

Find many

CamaDB uses a MongoDB style query language, powered by SiftJS. Have a look at that project to see the full capabilities of that library.

 const findResult = await collection.findMany({
_id: {
$gte: 50000,
},
},
{
sort:{
desc: x => x._id
},
offset: 100,
limit: 100
});

Updating

Again we use a MongoDB style language for data updates, for this we use obop

  await collection.updateMany({
_id:3
}, {
$set: {
steve:"steve"
}
});

Aggregation

We use Mingo for aggregation - currently lookup commands aren't supported.

 const aggregationResult = await collection.aggregate([{
$match:{
_id:3
}
}]);

Generated using TypeDoc