feat: CBOR TAG (#38)

* feat: CBOR TAG

package.json

@@ -40,13 +40,16 @@
  "borc": "^2.0.2",
  "bs58": "^4.0.0",
  "cids": "^0.4.0",
+ "is-circular": "^1.0.1",
  "multihashes": "^0.3.2",
  "multihashing-async": "^0.4.0",
  "traverse": "^0.6.6"
  },
  "devDependencies": {
  "aegir": "^9.4.0",
  "chai": "^3.5.0",
+ "deep-freeze": "0.0.1",
+ "garbage": "0.0.0",
  "ipfs-block": "^0.5.4",
  "pre-commit": "^1.2.2"
  },
@@ -59,4 +62,4 @@
  "npmcdn-to-unpkg-bot <npmcdn-to-unpkg-bot@users.noreply.github.com>",
  "wanderer <mjbecze@gmail.com>"
  ]
-}
+}

src/util.js

@@ -5,39 +5,90 @@ const multihashing = require('multihashing-async')
 const CID = require('cids')
 const waterfall = require('async/waterfall')
 const setImmediate = require('async/setImmediate')
+const isCircular = require('is-circular')
 
 const resolver = require('./resolver')
 
+// https://github.com/ipfs/go-ipfs/issues/3570#issuecomment-273931692
+const CID_CBOR_TAG = 42
+
+function tagCID (cid) {
+ return new cbor.Tagged(CID_CBOR_TAG, cid)
+}
+
+const decoder = new cbor.Decoder({
+ tags: {
+ [CID_CBOR_TAG]: (val) => ({'/': val})
+ }
+})
+
+function replaceCIDbyTAG (dagNode) {
+ if (isCircular(dagNode)) {
+ throw new Error('The object passed has circular references')
+ }
+
+ function transform (obj) {
+ if (!obj || Buffer.isBuffer(obj) || typeof obj === 'string') {
+ return obj
+ }
+
+ if (Array.isArray(obj)) {
+ return obj.map(transform)
+ }
+
+ const keys = Object.keys(obj)
+
+ // only `{'/': 'link'}` are valid
+ if (keys.length === 1 && keys[0] === '/') {
+ // Multiaddr encoding
+ // if (typeof link === 'string' && isMultiaddr(link)) {
+ // link = new Multiaddr(link).buffer
+ // }
+
+ return tagCID(obj['/'])
+ } else if (keys.length > 0) {
+ // Recursive transform
+ let out = {}
+ keys.forEach((key) => {
+ if (typeof obj[key] === 'object') {
+ out[key] = transform(obj[key])
+ } else {
+ out[key] = obj[key]
+ }
+ })
+ return out
+ } else {
+ return obj
+ }
+ }
+
+ return transform(dagNode)
+}
+
 exports = module.exports
 
 exports.serialize = (dagNode, callback) => {
  let serialized
+
  try {
- serialized = cbor.encode(dagNode)
+ const dagNodeTagged = replaceCIDbyTAG(dagNode)
+ serialized = cbor.encode(dagNodeTagged)
  } catch (err) {
- // return is important, otherwise in case of error the execution would continue
- return setImmediate(() => {
- callback(err)
- })
+ return setImmediate(() => callback(err))
  }
- setImmediate(() => {
- callback(null, serialized)
- })
+ setImmediate(() => callback(null, serialized))
 }
 
 exports.deserialize = (data, callback) => {
- let res
+ let deserialized
+
  try {
- res = cbor.decodeFirst(data)
+ deserialized = decoder.decodeFirst(data)
  } catch (err) {
- return setImmediate(() => {
- callback(err)
- })
+ return setImmediate(() => callback(err))
  }
 
- setImmediate(() => {
- callback(null, res)
- })
+ setImmediate(() => callback(null, deserialized))
 }
 
 exports.cid = (dagNode, callback) => {

test/util.spec.js

@@ -2,19 +2,35 @@
 'use strict'
 
 const expect = require('chai').expect
+const deepFreeze = require('deep-freeze')
+const garbage = require('garbage')
+const map = require('async/map')
 const dagCBOR = require('../src')
 
 describe('util', () => {
  const obj = {
  someKey: 'someValue',
- link: { '/': 'aaaaa' }
+ link: { '/': 'aaaaa' },
+ links: [{'/': 1}, {'/': 2}],
+ nested: {
+ hello: 'world',
+ link: { '/': 'mylink' }
+ }
  }
 
  it('.serialize and .deserialize', (done) => {
+ // freeze, to ensure we don't change the source objecdt
+ deepFreeze(obj)
  dagCBOR.util.serialize(obj, (err, serialized) => {
  expect(err).to.not.exist
  expect(Buffer.isBuffer(serialized)).to.be.true
 
+ // Check for the tag 42
+ // d8 = tag, 2a = 42
+ expect(
+ serialized.toString('hex').match(/d82a/g)
+ ).to.have.length(4)
+
  dagCBOR.util.deserialize(serialized, (err, deserialized) => {
  expect(err).to.not.exist
  expect(obj).to.eql(deserialized)
@@ -42,4 +58,29 @@ describe('util', () => {
  done()
  })
  })
+
+ it('serialize and deserialize - garbage', (done) => {
+ const inputs = []
+ for (let i = 0; i < 1000; i++) {
+ inputs.push({in: garbage(100)})
+ }
+
+ map(inputs, (input, cb) => {
+ dagCBOR.util.serialize(input, cb)
+ }, (err, encoded) => {
+ if (err) {
+ return done(err)
+ }
+ map(encoded, (enc, cb) => {
+ dagCBOR.util.deserialize(enc, cb)
+ }, (err, out) => {
+ if (err) {
+ return done(err)
+ }
+
+ expect(inputs).to.be.eql(out)
+ done()
+ })
+ })
+ })
 })