StoneSkin

Isomorphic IndexedDb and in-memory db wrapper with jsonschema validation.

$ npm install stone-skin --save

Inspired by mWater/minimongo. And based on thin indexedDb wrapper mizchi/idb-wrapper-promisify

Features

• ActiveRecord like API
• Universal indexedDb or in-memory object
• Promisified
• Runnable in shared-worker and service-worker
• (optional) validation by jsonschema(tv4)
• Selectable target
  • IndexedDb(browser)
  • LocalStorageDb(browser)
  • FileDb(node)
  • MemoryDb(universal)

FileDb and LocalStorageDb do just only serialization to json/string. Don't use them with big data.

Example

with babel(>=4.7.8) async/await (babel --experimental)

global.Promise = require('bluebird');

import "babel/polyfill";
import StoneSkin from 'stone-skin';

class ItemStore extends StoneSkin.IndexedDb {
  storeName: 'Item';
  schema: {
    properties: {
      title: {
        type: 'string'
      }
    }
  }
}

let itemStore = new ItemStore();
(async () => {
  await itemStore.ready;
  await itemStore.save({title: 'foo', _id: 'xxx'});
  let item = await itemStore.find('xxx');
  console.log(item);
  let items = await itemStore.all();
  console.log(items);
})();

with coffee

StoneSkin = require('stone-skin/with-tv4')

class Item extends StoneSkin.IndexedDb
  storeName: 'Item'
  schema:
    properties:
      title:
        type: 'string'
      body:
        type: 'string'

item = new Item
item.ready
.then ->
  item.clear()
.then ->
  item.all()
.then (items) ->
  console.log items
.then ->
  item.save {
    _id: 'xxx'
    title: 'test2'
    body: 'hello'
  }
.then ->
  item.save [
    {
      _id: 'yyy'
      title: 'test1'
      body: 'hello'
    }
  ]
.then ->
  item.all()
.then (items) ->
  console.log items
  item.remove 'xxx'
.then ->
  item.all()
.then (items) ->
  console.log items

with TypeScript

///<reference path='stone-skin.d.ts' />
var StoneSkin = require('stone-skin/with-tv4');

interface ItemSchema = {
  _id: string;
  title: string;
};

class Item extends StoneSkin<ItemSchema> {
  // ...
}

See detail stone-skin.d.ts)

Promisified Db API

StoneSkin.IndexedDb and StoneSkin.MemoryDb have same API

• ready: Promise<any>: return resolved promise if indexedDb ready.
• find(id: Id): Promise<T>: get first item by id
• select(fn: (t: T) => boolean): Promise<T[]>: filtered items by function
• first(fn: (t: T) => boolean): Promise<T>: get first item from filtered items
• last(fn: (t: T) => boolean): Promise<T>: get last item from filtered items
• all(): Promise<T[]>: return all items
• clear(): Promise<void>: remove all items
• save(t: T): Promise<T>: save item
• save(ts: T[]): Promise<T[]>: save items
• remove(id: Id): Promise<void>: remove item
• remove(ids: Id[]): Promise<void>: remove items

StoneSkin.IndexedDb

• storeName: string; You need to set this value when you extend it.
• StoneSkin.IndexedDb<T>.prototype.toMemoryDb(): StoneSkin.MemoryDb: return memory db by its items
• StoneSkin.IndexedDb<T>.prototype.toSyncedMemoryDb(): StoneSkin.SyncedMemoryDb: return synced memory db by its items.

StoneSkin.FileDb

• filepath: string; You need to set this value when you extend it.

StoneSkin.LocalStorageDb

• key: string; You need to set this value when you extend it.

StoneSkin.SyncedMemoryDb

It has almost same API without Promise wrap.

Migration helper

• StoneSkin.utils.setupWithMigrate(currentVersion: number);

StoneSkin.utils.setupWithMigrate 3,
  initialize: ->
    console.log 'init'        # fire at only first
  '1to2': ->
    console.log 'exec 1 to 2' # fire if last setup version is 1
  '2to3': ->
    console.log 'exec 2 to 3' # fire it if last setup version is 1 or 2

Need localStorage to save last version. It only works on browser.

LICENSE

MIT