CamaDB

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

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

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
    }
  }]);

elmarti/camadb