From d4bb501cca96857407563ba77fabb37bd47a784d Mon Sep 17 00:00:00 2001 From: David Dias Date: Thu, 1 Dec 2016 16:39:26 +0000 Subject: [PATCH] feat: dag-api (WIP) --- API/dag/README.md | 46 ++++++++++--- src/dag.js | 170 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 207 insertions(+), 9 deletions(-) create mode 100644 src/dag.js diff --git a/API/dag/README.md b/API/dag/README.md index ae5e3be0..03fdd7d6 100644 --- a/API/dag/README.md +++ b/API/dag/README.md @@ -1,6 +1,8 @@ dag API ======= +> The dag API comes to replace the `object API`, it support the creation and manipulation of dag-pb object, as well as other IPLD formats (i.e dag-cbor, ethereum-block, git, etc) + #### `dag.put` > Store an IPLD format node @@ -9,13 +11,10 @@ dag API ##### `JavaScript` - ipfs.dag.put(dagNode, formatMulticodec, hashAlg, callback) -`dagNode` - a DAG node that follows one of the supported IPLD formats. - -`formatMulticodec` - The IPLD format multicodec. - -`hashAlg` - The hash algorithm to be used over the serialized dagNode. - -`callback` must follow `function (err) {}` signature, where `err` is an error if the operation was not successful. +- `dagNode` - a DAG node that follows one of the supported IPLD formats. +- `formatMulticodec` - The IPLD format multicodec. +- `hashAlg` - The hash algorithm to be used over the serialized dagNode. +- `callback` must follow `function (err) {}` signature, where `err` is an error if the operation was not successful. If no `callback` is passed, a [promise][] is returned. @@ -25,10 +24,39 @@ If no `callback` is passed, a [promise][] is returned. ##### `Go` **WIP** -##### `JavaScript` - ipfs.object.get(cid, callback) +##### `JavaScript` - ipfs.dag.get(cid, callback) -`cid` is a [CID][https://github.com/ipfs/js-cid] instance. +- `cid` is a [CID][https://github.com/ipfs/js-cid] instance. `callback` must follow `function (err, dagNode) {}` signature, where `err` is an error if the operation was not successful and `dagNode` is the IPLD format DAG node retrieved. If no `callback` is passed, a [promise][] is returned. + +#### `dag.resolve` + +> Resolves an IPLD path + +##### `Go` **WIP** + +##### `JavaScript` - ipfs.dag.resolve(cid, path, callback) + +- `cid` is a [CID][https://github.com/ipfs/js-cid] instance. +- `path` is a String that represents a valid path to be resolved + +`callback` must follow `function (err, value) {}` signature, where `err` is an error if the operation was not successful and `value` is the value it was retrieved. + +If no `callback` is passed, a [promise][] is returned. + +#### `dag.remove` + +> Deletes an IPLD node + +##### `Go` **WIP** + +##### `JavaScript` - ipfs.dag.rm(cid, callback) + +- `cid` is a [CID][https://github.com/ipfs/js-cid] instance. + +`callback` must follow `function (err) {}` signature, where `err` is an error if the operation was not successful. + +If no `callback` is passed, a [promise][] is returned. diff --git a/src/dag.js b/src/dag.js new file mode 100644 index 00000000..9c141319 --- /dev/null +++ b/src/dag.js @@ -0,0 +1,170 @@ +/* eslint-env mocha */ +/* eslint max-nested-callbacks: ["error", 8] */ + +'use strict' + +const expect = require('chai').expect +const dagPB = require('ipld-dag-pb') +const DAGNode = dagPB.DAGNode +const dagCBOR = require('ipld-dag-pb') +// const series = require('async/series') + +module.exports = (common) => { + describe('.dag', () => { + let ipfs + + before(function (done) { + // CI is slow + this.timeout(20 * 1000) + + common.setup((err, factory) => { + expect(err).to.not.exist + factory.spawnNode((err, node) => { + expect(err).to.not.exist + ipfs = node + done() + }) + }) + }) + + after((done) => { + common.teardown(done) + }) + + describe('callback API', () => { + let pbNode + let cborNode + + before((done) => { + const someData = new Buffer('some data') + + pbNode = DAGNode.create(someData, (err, node) => { + expect(err).to.not.exist + pbNode = node + done() + }) + + cborNode = { + data: someData + } + }) + + describe('.put', () => { + it('dag-pb with default hash func (sha2-256)', (done) => { + ipfs.dag.put(pbNode, 'dag-pb', 'sha2-256', done) + }) + + it('dag-pb with custom hash func (sha3-512)', (done) => { + ipfs.dag.put(pbNode, 'dag-pb', 'sha3-512', done) + }) + + it('dag-pb node with wrong multicodec', (done) => { + ipfs.dag.put(pbNode, 'dag-cbor', 'sha3-512', (err) => { + expect(err).to.exist + done() + }) + }) + + it('dag-cbor with default hash func (sha2-256)', (done) => { + ipfs.dag.put(cborNode, 'dag-cbor', 'sha2-256', done) + }) + + it('dag-cbor with custom hash func (sha3-512)', (done) => { + ipfs.dag.put(cborNode, 'dag-cbor', 'sha3-512', done) + }) + + it('dag-cbor node with wrong multicodec', (done) => { + ipfs.dag.put(cborNode, 'dag-pb', 'sha3-512', (err) => { + expect(err).to.exist + done() + }) + }) + }) + + describe('.get', () => { + let pbNode + let cborNode + + before((done) => { + const someData = new Buffer('some other data') + + pbNode = DAGNode.create(someData, (err, node) => { + expect(err).to.not.exist + pbNode = node + done() + }) + + cborNode = { + data: someData + } + }) + + it('dag-pb node', (done) => { + ipfs.dag.put(pbNode, 'dag-pb', 'sha2-256', (err) => { + expect(err).to.not.exist + dagPB.util.cid(pbNode, (err, cid) => { + expect(err).to.not.exist + ipfs.dag.get(cid, (err, node) => { + expect(err).to.not.exist + expect(pbNode.toJSON()).to.eql(node.toJSON()) + done() + }) + }) + }) + }) + + it('dag-cbor node', (done) => { + ipfs.dag.put(cborNode, 'dag-cbor', 'sha2-256', (err) => { + expect(err).to.not.exist + dagCBOR.util.cid(cborNode, (err, cid) => { + expect(err).to.not.exist + ipfs.dag.get(cid, (err, node) => { + expect(err).to.not.exist + expect(cborNode).to.eql(node) + done() + }) + }) + }) + }) + }) + + describe('.resolve', () => {}) + + describe('.rm', () => { + let pbNode + + before((done) => { + const someData = new Buffer('some other data') + + pbNode = DAGNode.create(someData, (err, node) => { + expect(err).to.not.exist + pbNode = node + done() + }) + }) + + it('dag-pb node', (done) => { + ipfs.dag.put(pbNode, 'dag-pb', 'sha2-256', (err) => { + expect(err).to.not.exist + dagPB.util.cid(pbNode, (err, cid) => { + expect(err).to.not.exist + ipfs.dag.get(cid, (err, node) => { + expect(err).to.not.exist + ipfs.dag.rm(cid, done) + // TODO When we get timeouts in js-ipfs, try to fetch again + // and observe it timesout without the node + }) + }) + }) + }) + }) + }) + + describe('promise API', () => { + describe('.put', () => {}) + describe('.get', () => {}) + describe('.resolve', () => {}) + describe('.rm', () => {}) + }) + }) +}