feat: follow new dag-pb interface (from new interface-ipld-format

ipld · Oct 17, 2016 · 91ecfa4 · 91ecfa4
1 parent 0818945
commit 91ecfa4
Show file tree

Hide file tree

Showing 2 changed files with 45 additions and 31 deletions.
diff --git a/src/index.js b/src/index.js
@@ -27,15 +27,16 @@ class IPLDResolver {
     this.resolvers = {}
 
     // Support by default dag-pb and dag-cbor
-    this.support(dagPB.resolver.multicodec, dagPB.DAGNode, dagPB.resolver)
+    this.support(dagPB.resolver.multicodec, dagPB.DAGNode, dagPB.resolver, dagPB.util)
     // this.support(dagCBOR.resolver.multicodec, dagCBOR.DAGNode, dagCBOR.resolver)
   }
 
   // Adds support for an IPLD format
   // default ones are dag-pb and dag-cbor
-  support (multicodec, type, resolver) {
+  support (multicodec, type, resolver, util) {
     this.resolvers[multicodec] = {
       resolver: resolver,
+      util: util,
       Type: type
     }
   }
@@ -84,10 +85,10 @@ class IPLDResolver {
 
   // Node operations (get and retrieve nodes, not values)
 
-  put (node, callback) {
+  put (nodeAndCID, callback) {
     callback = callback || noop
     pull(
-      pull.values([node]),
+      pull.values([nodeAndCID]),
       this.putStream(callback)
     )
   }
@@ -96,10 +97,12 @@ class IPLDResolver {
     callback = callback || noop
 
     return pull(
-      pull.map((node) => {
+      pull.map((nodeAndCID) => {
+        const cid = nodeAndCID.cid
+        const r = this.resolvers[cid.codec]
         return {
-          block: new Block(node.serialize()),
-          cid: node.cid()
+          block: new Block(r.util.serialize(nodeAndCID.node)),
+          cid: cid
         }
       }),
       this.bs.putStream(),
@@ -123,10 +126,9 @@ class IPLDResolver {
     return pull(
       this.bs.getStream(cid),
       pull.map((block) => {
-        if (this.resolvers[cid.codec]) {
-          const node = new this.resolvers[cid.codec].Type()
-          node.deserialize(block.data)
-          return node
+        const r = this.resolvers[cid.codec]
+        if (r) {
+          return r.util.deserialize(block.data)
         } else { // multicodec unknown, send back raw data
           return block.data
         }

diff --git a/test/test-ipld-dag-pb.js b/test/test-ipld-dag-pb.js
@@ -30,24 +30,30 @@ module.exports = (repo) => {
     })
 
     it('resolver.put', (done) => {
-      resolver.put(node1, done)
+      resolver.put({
+        node: node1,
+        cid: dagPB.util.cid(node1)
+      }, done)
     })
 
     it('resolver.putStream', (done) => {
       pull(
         pull.values([
-          node1,
-          node2,
-          node3
+          { node: node1, cid: dagPB.util.cid(node1) },
+          { node: node2, cid: dagPB.util.cid(node2) },
+          { node: node3, cid: dagPB.util.cid(node3) }
         ]),
         resolver.putStream(done)
       )
     })
 
     it('resolver.get', (done) => {
-      resolver.put(node1, (err) => {
+      resolver.put({
+        node: node1,
+        cid: dagPB.util.cid(node1)
+      }, (err) => {
         expect(err).to.not.exist
-        resolver.get(node1.cid(), (err, node) => {
+        resolver.get(dagPB.util.cid(node1), (err, node) => {
           expect(err).to.not.exist
           expect(node.multihash()).to.eql(node.multihash())
           done()
@@ -56,10 +62,13 @@ module.exports = (repo) => {
     })
 
     it('resolver.getStream', (done) => {
-      resolver.put(node1, (err) => {
+      resolver.put({
+        node: node1,
+        cid: dagPB.util.cid(node1)
+      }, (err) => {
         expect(err).to.not.exist
         pull(
-          resolver.getStream(node1.cid()),
+          resolver.getStream(dagPB.util.cid(node1)),
           pull.collect((err, nodes) => {
             expect(err).to.not.exist
             expect(node1.multihash()).to.eql(nodes[0].multihash())
@@ -104,19 +113,22 @@ module.exports = (repo) => {
     })
 
     it('resolver.remove', (done) => {
-      resolver.put(node1, (err) => {
+      resolver.put({
+        node: node1,
+        cid: dagPB.util.cid(node1)
+      }, (err) => {
         expect(err).to.not.exist
-        resolver.get(node1.cid(), (err, node) => {
+        resolver.get(dagPB.util.cid(node1), (err, node) => {
           expect(err).to.not.exist
           expect(node.multihash()).to.eql(node.multihash())
           remove()
         })
       })
 
       function remove () {
-        resolver.remove(node1.cid(), (err) => {
+        resolver.remove(dagPB.util.cid(node1), (err) => {
           expect(err).to.not.exist
-          resolver.get(node1.cid(), (err, node) => {
+          resolver.get(dagPB.util.cid(node1), (err) => {
             expect(err).to.exist
             done()
           })
@@ -146,40 +158,40 @@ module.exports = (repo) => {
 
       pull(
         pull.values([
-          node1,
-          node2,
-          node3
+          { node: node1, cid: dagPB.util.cid(node1) },
+          { node: node2, cid: dagPB.util.cid(node2) },
+          { node: node3, cid: dagPB.util.cid(node3) }
         ]),
         resolver.putStream(done)
       )
     })
 
     it('root path (same as get)', (done) => {
-      resolver.resolve(node1.cid(), '/', (err, result) => {
+      resolver.resolve(dagPB.util.cid(node1), '/', (err, result) => {
         expect(err).to.not.exist
-        expect(result.cid()).to.eql(node1.cid())
+        expect(dagPB.util.cid(result)).to.eql(dagPB.util.cid(node1))
         done()
       })
     })
 
     it('value within 1st node scope', (done) => {
-      resolver.resolve(node1.cid(), 'data', (err, result) => {
+      resolver.resolve(dagPB.util.cid(node1), 'data', (err, result) => {
         expect(err).to.not.exist
         expect(result).to.eql(new Buffer('I am 1'))
         done()
       })
     })
 
     it('value within nested scope (1 level)', (done) => {
-      resolver.resolve(node2.cid(), 'links/0/data', (err, result) => {
+      resolver.resolve(dagPB.util.cid(node2), 'links/0/data', (err, result) => {
         expect(err).to.not.exist
         expect(result).to.eql(new Buffer('I am 1'))
         done()
       })
     })
 
     it('value within nested scope (2 levels)', (done) => {
-      resolver.resolve(node3.cid(), 'links/1/links/0/data', (err, result) => {
+      resolver.resolve(dagPB.util.cid(node3), 'links/1/links/0/data', (err, result) => {
         expect(err).to.not.exist
         expect(result).to.eql(new Buffer('I am 1'))
         done()