Skip to content
levelup based modella relations
JavaScript Makefile
Latest commit daf43e1 Nov 30, 2015 @ramitos Update readme.md
Failed to load latest commit information.
src
test add failing test Dec 13, 2013
.coveralls.yml add code climate badge Nov 30, 2013
.gitignore
.jshintrc initial commit Nov 29, 2013
.tern-project initial commit Nov 30, 2013
.travis.yml initial commit Nov 30, 2013
Makefile add `get` tests Nov 30, 2013
license
package.json missing dependency Jan 7, 2014
readme.md Update readme.md Nov 30, 2015

readme.md

deprecated

modella-level-relations

NPM version Build Status Dependency Status Coverage Status

install

npm install [--save/--save-dev] modella-level-relations

example

var relations = require('modella-level-relations'),
    modella = require('modella'),
    sublevel = require('sublevel'),
    store = require('level-modella'),
    level = require('level'),
    timehat = require('timehat')
    assert = require('assert'),
    series = require('map-series')

var db = level('/tmp/relations')
var sub = sublevel(db)
var User = modella('User')

User.use(store(sub.sublevel('users')))
User.use(relations.plugin(sub.sublevel('relations')))
User.attr('id')
User.attr('name')

var frank = User({
  id: timehat(),
  name: 'frank'
})

var charlie = User({
  id: timehat(),
  name: 'charlie'
})

series([frank, charlie], function (user, fn) {
  user.save(fn)
}, function (err) {
  if(err) throw err

  User.relation('followers').put(frank, charlie, function (err, relation) {
    if(err) throw err

    var now = new Date()
    assert(relation.from === frank.primary())
    assert(relation.to === charlie.primary())
    assert(typeof relation.id === 'string')
    assert(relation.id.length > 0)
    assert(timehat.toDate(relation.id).getUTCMonth() === now.getUTCMonth())
    assert(timehat.toDate(relation.id).getUTCDate() === now.getUTCDate())
    assert(timehat.toDate(relation.id).getUTCHours() === now.getUTCHours())
    assert(timehat.toDate(relation.id).getYear() === now.getYear())


    User.relation('followers').get(frank).on('data', function (follower) {
      assert(follower.name() === charlie.name())
      assert(follower.primary() === charlie.primary())
      assert(follower.__relation === relation.id)
    })
  })
})

api

use

On every Model that needs relations, Model.use should be called:

var relations = require('modella-level-relations')
var store = require('level-modella')
var level = require('level')('/path/to/my/db')

var User = modella('User')
User.use(store(level))
User.use(relations.plugin(level))

Important: modella-level-relations requires level as the modella backend.

put(from, to, callback)

User.relation('followers').put(model_instance_a, model_instance_b, function (err, relation) {})

emits pre relation and relation events

has(from, to, callback)

User.relation('followers').has(model_instance_a, model_instance_b, function (err, has) {})

get(from[, options])

User.relation('followers').get(model_instance_a).on('data', function (follower) {})

each(from[, options], each, end)

User.relation('followers').each(model_instance_a, function (follower) {}, function (err) {})

all(from[, options], fn)

User.relation('followers').all(model_instance_a, function (err, followers) {})

one(from[, options], fn)

Todo.relation('author').one(todo, function (err, author) {})

options

  • start: the relation id key you wish to start the read at.
  • end: the relation id key you wish to end the read at.
  • reverse (boolean, default: true): by default, the relations are fetched in reverse order: the last added relation is the first to be fetched
  • limit (number, default: -1): limit the number of results

del(from, to, callback)

User.relation('followers').del(model_instance_a, model_instance_b, function (err) {})

emits relation event

delAll(from, callback)

User.relation('followers').delAll(model_instance_a, function (err) {})

count(from, callback)

User.relation('followers').count(model_instance_a, function (err, count) {})

toggle(from, to, callback)

User.relation('followers').toggle(model_instance_a, function (err) {})

relations.put(from, to, callback)

var relations = require('modella-level-relations')

// `a` -> following -> `b`
// `b` -> followers -> `a`
relations('following', 'followers').put(a, b, function (err, relations) {})

relations.del(from, to, callback)

var relations = require('modella-level-relations')

// `a` -> !following -> `b`
// `b` -> !followers -> `a`
relations('following', 'followers').del(a, b, function (err, relations) {})

relations.delAll(from, to, callback)

var relations = require('modella-level-relations')

// `a` -> !following -> all
// each -> !followers -> `a`
relations('following', 'followers').delAll(a, function (err) {})

relations.has(from, to, callback)

var relations = require('modella-level-relations')

// (`a` -> following -> `b`) && (`b` -> followers -> `a`)
relations('following', 'followers').has(a, b, function (err, has) {})

relations.toggle(from, to, callback)

var relations = require('modella-level-relations')

// `a` -> !following -> `b`
// `b` -> !followers -> `a`
relations('following', 'followers').toggle(a, b, function (err, relations) {})

license

MIT

Something went wrong with that request. Please try again.