Skip to content
An underscore API for PouchDB with added bonuses
JavaScript
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.gitignore
README.md
logo.svg
package.json
test.js
underpouch.js

README.md

underpouch logo

An underscore API for PouchDB with added bonuses!

npm install underpouch

usage

var PouchDB = require('pouchdb')
var _pouch = require('underpouch')

var db = new PouchDB('db')

Now you can query PouchDB with familiar _.underscore functions:

_pouch.findWhere(db, { author: "Shakespeare", year: 1611 }, (err, doc) => {
    //doc = { _id: 'example', _rev: 'xxx...', title: "Cymbeline", author: "Shakespeare", year: 1611 }
})

(note that the following examples return docs with _id and _rev but are trimmed, unless otherwise indicated, for brevity)

Collections (for sifting, sorting docs)


find
_pouch.find(db, truthTest, callback)
Looks through each doc in the db, returning the first one that passes a truth test.

  _pouch.find(db, (doc) => doc.magicNumber % 2 == 0, (err, doc) => {
    //doc = { name: 'magicDoc', magicNumber: 2 }
  })

filter
_pouch.filter(db, truthTest, callback)
Looks through each doc in the db, returning an array of docs that pass a truth test.

  _pouch.filter(db, (doc) => doc.number % 2 == 0, (err, docs) => {
    //docs = [{ number: 2 }, { number: 4 }, { number: 6 }}
  })

where
_pouch.where(db, properties, callback)
Looks through each doc in the db, returning an array of all the docs that contain all of the key-value pairs listed in properties.

  _pouch.where(playsDb, { author: "Shakespeare", year: 1611 }, (err, docs) => {
    /*docs = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 },
    { title: "The Tempest", author: "Shakespeare", year: 1611 }] */
  })

findWhere
_pouch.findWhere(db, properties, callback)
Looks through the list and returns the first value that matches all of the key-value pairs listed in properties.

  _pouch.findWhere(db, {newsroom: "The New York Times"}, (err, doc) => {
    //doc = { year: 1918, newsroom: "The New York Times", reason: "For its public service in publishing in full so many official reports, documents and speeches by European statesmen relating to the progress and conduct of the war."}  
  })

max
Returns the doc with the maximum value. If no iteratee function is provided, defaults to _.id (parseInt will be used).

  _pouch.max(db, (stoogeDoc) => stoogeDoc.age, (err, doc) => {
    //doc = { name: 'curly', age: 60 }
  })

all !
_pouch.all(db, callback)
Returns an array of all the docs in the db

  _pouch.all(db, (err, allDocs) => {
    //allDocs = [{_id: 'all'},{_id: 'the'}, {_id: 'docs'}]
  })

deleteNow !
_pouch.deleteDocs(db, docOrDocId, callback)
Deletes a given document without requiring revision or giving up on conflict (adds { _deleted : true })

  let doc = { _id : 'any' , _rev : 'thing' }
  _pouch.deleteNow(db, doc, (err) => {
    //err if doc not found
  })

deleteDocs !
_pouch.deleteDocs(db, callback)
Deletes all docs in database, without deleting the database (adds { _deleted : true } to each doc)

  _pouch.deleteDocs(db, (err, res) => {
    //res is a list of the ids/revs of the deleted docs
  })

Object Functions (for modifying docs)


extend
_pouch.extend(db, destinationDocId, sourceDoc, callback)
Copy all of the properties in the source doc over to the destination doc, put and return the destination doc with its updated rev. It's in-order, so the last source will override properties of the same name in previous arguments.

  _pouch.extend(db, 'user', { email: jeff@gmail.com }, (err, updatedDoc) => {
    //updatedDoc = { email: "jeff@gmail.com", name: "Jeff", age: 35 }
  })

extendPut !
_pouch.extendPut(db, destinationDocId, sourceDoc, callback)
Like _pouch.extend but put()'s the sourceDoc even if destination doc is not existing.

  _pouch.extendPut(db, { 'some-id-that-doesnt-exist', {name: "Sara"}, (err, extendedDoc) => {
    //extendedDoc = { _id: "some-id-that-doesnt-exist", name: "Sara" }
  })

extendPutOrPost !
_pouch.extendPutOrPost(db, destinationDoc, sourceDoc, callback)
Like _pouch.extendPut but will post() the doc if no id is provided.

  _pouch.extendPut(db, {name: "Sara"}, (err, extendedDoc) => {
    //extendedDoc = { _id: "262db426-2b2a...", name: "Sara" }
  })

merge ! (lodash)
_pouch.merge(db, destinationDocId, sourceDoc, callback)
Like _pouch.extend but uses lodash's merge so that child properties are merged, not overwritten. Ie: _pouch.extend will overwrite properties whereas _pouch.merge will merge them.

  //originalDoc = { _.id: 'food', fruits: ['mango', 'lemon']}
  _pouch.merge(db, 'food', { fruits: ['lime, kiwi'] }, (err, updatedDoc) => {
    //updatedDoc = { _.id: 'food', fruits: ['mango', 'lemon', 'lime', 'kiwi']}
  })

mergePutOrPost !
_pouch.merge(db, destinationDocId, sourceDoc, callback)
Like _pouch.mergePutOrPost but will post (if no _id) or put the doc if not already existing.

  _pouch.mergePutOrPost(db, { fruits: ['lime, kiwi'] }, (err, updatedDoc) => {
    //updatedDoc = { _.id: "262db426-2b2a...", fruits: ['lime, kiwi']}
  })

replace ! _pouch.replace(db, doc, callback) Overwrites an existing doc, regardless of revision (shortcut for doing db.get and then db.put) or if doc existing or not (posts if not existing).

  //no doc existing: 
  _p.replace(db, { _id : 'favorite-food', value : 'pizza' }, (err, replacedDoc) => {
    //no rev necessary: 
    _p.replace(db, { _id : 'favorite-food', value : 'ice cream' }, (err, repacedDoc2) => {
      //replacedDoc2 = { _id : 'favorite-food', value : 'ice cream' } }
    })
  })
You can’t perform that action at this time.