clean up and updates

Author: dignifiedquire

API.md

@@ -6,10 +6,14 @@ const BlockService = require('ipfs-block-service')
 
 ### `new BlockService(repo)`
 
+- `repo: Repo`
+
 Creates a new block service backed by [IPFS Repo][repo] `repo` for storage.
 
 ### `goOnline(bitswap)`
 
+- `bitswap: Bitswap`
+
 Add a bitswap instance that communicates with the network to retreive blocks
 that are not in the local store.
 
@@ -24,53 +28,40 @@ Remove the bitswap instance and fall back to offline mode.
 
 Returns a `Boolean` indicating if the block service is online or not.
 
-### `addBlock(block, callback(err))`
+### `put(block, callback)`
+
+- `block: Block`
+- `callback: Function`
 
 Asynchronously adds a block instance to the underlying repo.
 
-### `addBlocks(blocks, callback(err))`
+### `putStream()`
 
-Asynchronously adds an array of block instances to the underlying repo.
+Returns a through pull-stream, which `Block`s can be written to, and
+that emits the meta data about the written block.
 
-*Does not guarantee atomicity.*
+### `get(multihash [, extension], callback)`
 
-### `getBlock(multihash, callback(err, block))`
+- `multihash: Multihash`
+- `extension: String`, defaults to 'data'
+- `callback: Function`
 
 Asynchronously returns the block whose content multihash matches `multihash`.
-Returns an error (`err.code === 'ENOENT'`) if the block does not exist.
-
-If the block could not be found, expect `err.code` to be `'ENOENT'`.
-
-### `getBlocks(multihashes, callback(err, blocks))`
-
-Asynchronously returns the blocks whose content multihashes match the array
-`multihashes`.
-
-`blocks` is an object that maps each `multihash` to an object of the form
-
-```js
-{
-  err: Error
-  block: Block
-}
-```
-
-Expect `blocks[multihash].err.code === 'ENOENT'`  and `blocks[multihash].block
-=== null` if a block did not exist.
 
-*Does not guarantee atomicity.*
+### `getStream(multihash [, extension])`
 
-### `deleteBlock(multihash, callback(err))`
+- `multihash: Multihash`
+- `extension: String`, defaults to 'data'
 
-Asynchronously deletes the block from the store with content multihash matching
-`multihash`, if it exists.
+Returns a source pull-stream, which emits the requested block.
 
-### `bs.deleteBlocks(multihashes, callback(err))`
+### `delete(multihashes, [, extension], callback)`
 
-Asynchronously deletes all blocks from the store with content multihashes matching
-from the array `multihashes`.
+- `multihashes: Multihash|[]Multihash`
+- `extension: String`, defaults to 'data'- `extension: String`, defaults to 'data'
+- `callback: Function`
 
-*Does not guarantee atomicity.*
+Deletes all blocks referenced by multihashes.
 
-[multihash]: https://github.com/jbenet/js-multihash
+[multihash]: https://github.com/multiformats/js-multihash
 [repo]: https://github.com/ipfs/specs/tree/master/repo

src/index.js

@@ -68,24 +68,18 @@ module.exports = class BlockService {
     return this._repo.blockstore.getStream(key, extension)
   }
 
-  deleteBlock (key, extension, callback) {
-    this._repo.blockstore.delete(key, extension, callback)
-  }
-
-  deleteBlocks (multihashes, extension, callback) {
+  delete (keys, extension, callback) {
     if (typeof extension === 'function') {
       callback = extension
       extension = undefined
     }
 
-    if (!Array.isArray(multihashes)) {
-      return callback(new Error('Invalid batch of multihashes'))
+    if (!Array.isArray(keys)) {
+      keys = [keys]
     }
 
-    parallelLimit(multihashes.map((multihash) => (next) => {
-      this.deleteBlock(multihash, extension, next)
-    }), 100, (err) => {
-      callback(err)
-    })
+    parallelLimit(keys.map((key) => (next) => {
+      this._repo.blockstore.delete(key, extension, next)
+    }), 100, callback)
   }
 }

test/block-service-test.js

@@ -108,7 +108,7 @@ module.exports = (repo) => {
         const b = new Block('Will not live that much')
         bs.put(b, (err) => {
           expect(err).to.not.exist
-          bs.deleteBlock(b.key, (err) => {
+          bs.delete(b.key, (err) => {
             expect(err).to.not.exist
             bs.get(b.key, (err, block) => {
               expect(err).to.exist
@@ -118,8 +118,8 @@ module.exports = (repo) => {
         })
       })
 
-      it('deleteBlock: bad invocation', (done) => {
-        bs.deleteBlock(null, (err) => {
+      it('delete: bad invocation', (done) => {
+        bs.delete(null, (err) => {
           expect(err).to.be.an('error')
           done()
         })
@@ -129,7 +129,7 @@ module.exports = (repo) => {
         const b = new Block('Will not live that much', 'ext')
         bs.put(b, (err) => {
           expect(err).to.not.exist
-          bs.deleteBlock(b.key, 'ext', (err) => {
+          bs.delete(b.key, 'ext', (err) => {
             expect(err).to.not.exist
             bs.get(b.key, 'ext', (err, block) => {
               expect(err).to.exist
@@ -141,7 +141,7 @@ module.exports = (repo) => {
 
       it('delete a non existent block', (done) => {
         const b = new Block('I do not exist')
-        bs.deleteBlock(b.key, (err) => {
+        bs.delete(b.key, (err) => {
           expect(err).to.not.exist
           done()
         })
@@ -152,19 +152,12 @@ module.exports = (repo) => {
         const b2 = new Block('2')
         const b3 = new Block('3')
 
-        bs.deleteBlocks([b1, b2, b3], 'data', (err) => {
+        bs.delete([b1, b2, b3], 'data', (err) => {
           expect(err).to.not.exist
           done()
         })
       })
 
-      it('deleteBlocks: bad invocation', (done) => {
-        bs.deleteBlocks(null, (err) => {
-          expect(err).to.be.an('error')
-          done()
-        })
-      })
-
       it('stores and gets lots of blocks', function (done) {
         this.timeout(60 * 1000)