fix: use @ipld/dag-pb instead of ipld-dag-pb

.travis.yml

@@ -1,5 +1,6 @@
 language: node_js
 cache: npm
+dist: focal
 
 branches:
   only:

packages/ipfs-unixfs-exporter/package.json

@@ -43,15 +43,10 @@
     "events": "^3.3.0",
     "ipfs-core-types": "^0.3.1",
     "ipfs-unixfs-importer": "^7.0.3",
-    "ipld": "^0.29.0",
-    "ipld-block": "^0.11.1",
-    "ipld-dag-pb": "^0.22.2",
-    "ipld-in-memory": "^8.0.0",
     "it-all": "^1.0.5",
     "it-buffer-stream": "^2.0.0",
     "it-first": "^1.0.6",
     "merge-options": "^3.0.4",
-    "multicodec": "^3.0.1",
     "native-abort-controller": "^1.0.3",
     "nyc": "^15.0.0",
     "readable-stream": "^3.6.0",
@@ -61,11 +56,14 @@
     "util": "^0.12.3"
   },
   "dependencies": {
-    "cids": "^1.1.5",
+    "@ipld/dag-cbor": "^5.0.0",
+    "@ipld/dag-pb": "^1.1.0",
     "err-code": "^3.0.1",
     "hamt-sharding": "^2.0.0",
     "ipfs-unixfs": "^4.0.3",
     "it-last": "^1.0.5",
+    "multicodec": "^3.0.1",
+    "multiformats": "^8.0.3",
     "multihashing-async": "^2.1.0"
   },
   "types": "dist/src/index.d.ts",

packages/ipfs-unixfs-exporter/src/index.js

@@ -1,14 +1,13 @@
 'use strict'
 
 const errCode = require('err-code')
-const CID = require('cids')
+const { CID } = require('multiformats/cid')
 const resolve = require('./resolvers')
 const last = require('it-last')
 
 /**
  * @typedef {import('ipfs-unixfs').UnixFS} UnixFS
- * @typedef {import('ipld-dag-pb').DAGNode} DAGNode
- * @typedef {import('ipld')} IPLD
+ * @typedef {import('ipfs-unixfs-importer/src/types').BlockAPI} BlockAPI
  * @typedef {import('./types').ExporterOptions} ExporterOptions
  * @typedef {import('./types').UnixFSFile} UnixFSFile
  * @typedef {import('./types').UnixFSDirectory} UnixFSDirectory
@@ -32,14 +31,15 @@ const toPathComponents = (path = '') => {
 const cidAndRest = (path) => {
   if (path instanceof Uint8Array) {
     return {
-      cid: new CID(path),
+      cid: CID.decode(path),
       toResolve: []
     }
   }
 
-  if (CID.isCID(path)) {
+  const cid = CID.asCID(path)
+  if (cid) {
     return {
-      cid: path,
+      cid,
       toResolve: []
     }
   }
@@ -52,7 +52,7 @@ const cidAndRest = (path) => {
     const output = toPathComponents(path)
 
     return {
-      cid: new CID(output[0]),
+      cid: CID.parse(output[0]),
       toResolve: output.slice(1)
     }
   }
@@ -62,10 +62,10 @@ const cidAndRest = (path) => {
 
 /**
  * @param {string | CID} path
- * @param {IPLD} ipld
+ * @param {BlockAPI} blockService
  * @param {ExporterOptions} [options]
  */
-async function * walkPath (path, ipld, options = {}) {
+async function * walkPath (path, blockService, options = {}) {
   let {
     cid,
     toResolve
@@ -75,7 +75,7 @@ async function * walkPath (path, ipld, options = {}) {
   const startingDepth = toResolve.length
 
   while (true) {
-    const result = await resolve(cid, name, entryPath, toResolve, startingDepth, ipld, options)
+    const result = await resolve(cid, name, entryPath, toResolve, startingDepth, blockService, options)
 
     if (!result.entry && !result.next) {
       throw errCode(new Error(`Could not resolve ${path}`), 'ERR_NOT_FOUND')
@@ -99,11 +99,11 @@ async function * walkPath (path, ipld, options = {}) {
 
 /**
  * @param {string | CID} path
- * @param {IPLD} ipld
+ * @param {BlockAPI} blockService
  * @param {ExporterOptions} [options]
  */
-async function exporter (path, ipld, options = {}) {
-  const result = await last(walkPath(path, ipld, options))
+async function exporter (path, blockService, options = {}) {
+  const result = await last(walkPath(path, blockService, options))
 
   if (!result) {
     throw errCode(new Error(`Could not resolve ${path}`), 'ERR_NOT_FOUND')
@@ -114,11 +114,11 @@ async function exporter (path, ipld, options = {}) {
 
 /**
  * @param {string | CID} path
- * @param {IPLD} ipld
+ * @param {BlockAPI} blockService
  * @param {ExporterOptions} [options]
  */
-async function * recursive (path, ipld, options = {}) {
-  const node = await exporter(path, ipld, options)
+async function * recursive (path, blockService, options = {}) {
+  const node = await exporter(path, blockService, options)
 
   if (!node) {
     return

packages/ipfs-unixfs-exporter/src/resolvers/dag-cbor.js

@@ -1,7 +1,8 @@
 'use strict'
 
-const CID = require('cids')
+const { CID } = require('multiformats/cid')
 const errCode = require('err-code')
+const dagCbor = require('@ipld/dag-cbor')
 
 /**
  * @typedef {import('../types').Resolver} Resolver
@@ -10,9 +11,9 @@ const errCode = require('err-code')
 /**
  * @type {Resolver}
  */
-const resolve = async (cid, name, path, toResolve, resolve, depth, ipld, options) => {
-  const object = await ipld.get(cid, options)
-  const block = await ipld.get(new CID(1, 'raw', cid.multihash))
+const resolve = async (cid, name, path, toResolve, resolve, depth, blockService, options) => {
+  const block = await blockService.get(cid)
+  const object = dagCbor.decode(block.bytes)
   let subObject = object
   let subPath = path
 
@@ -24,22 +25,23 @@ const resolve = async (cid, name, path, toResolve, resolve, depth, ipld, options
       toResolve.shift()
       subPath = `${subPath}/${prop}`
 
-      if (CID.isCID(subObject[prop])) {
+      const subObjectCid = CID.asCID(subObject[prop])
+      if (subObjectCid) {
         return {
           entry: {
             type: 'object',
             name,
             path,
             cid,
-            node: block,
+            node: block.bytes,
             depth,
             size: block.length,
             content: async function * () {
               yield object
             }
           },
           next: {
-            cid: subObject[prop],
+            cid: subObjectCid,
             name: prop,
             path: subPath,
             toResolve
@@ -60,7 +62,7 @@ const resolve = async (cid, name, path, toResolve, resolve, depth, ipld, options
       name,
       path,
       cid,
-      node: block,
+      node: block.bytes,
       depth,
       size: block.length,
       content: async function * () {

packages/ipfs-unixfs-exporter/src/resolvers/identity.js

@@ -3,7 +3,7 @@
 const errCode = require('err-code')
 const extractDataFromBlock = require('../utils/extract-data-from-block')
 const validateOffsetAndLength = require('../utils/validate-offset-and-length')
-const mh = require('multihashing-async').multihash
+const mh = require('multiformats/hashes/digest')
 
 /**
  * @typedef {import('../types').ExporterOptions} ExporterOptions
@@ -32,12 +32,11 @@ const rawContent = (node) => {
 /**
  * @type {Resolver}
  */
-const resolve = async (cid, name, path, toResolve, resolve, depth, ipld, options) => {
+const resolve = async (cid, name, path, toResolve, resolve, depth, blockService, options) => {
   if (toResolve.length) {
     throw errCode(new Error(`No link named ${path} found in raw node ${cid}`), 'ERR_NOT_FOUND')
   }
-
-  const buf = await mh.decode(cid.multihash)
+  const buf = await mh.decode(cid.multihash.bytes)
 
   return {
     entry: {
@@ -47,7 +46,7 @@ const resolve = async (cid, name, path, toResolve, resolve, depth, ipld, options
       cid,
       content: rawContent(buf.digest),
       depth,
-      size: buf.length,
+      size: buf.digest.length,
       node: buf.digest
     }
   }

packages/ipfs-unixfs-exporter/src/resolvers/index.js

@@ -1,10 +1,10 @@
 'use strict'
 
 const errCode = require('err-code')
+const multicodec = require('multicodec')
 
 /**
- * @typedef {import('cids')} CID
- * @typedef {import('ipld')} IPLD
+ * @typedef {import('../').BlockAPI} BlockAPI
  * @typedef {import('../types').ExporterOptions} ExporterOptions
  * @typedef {import('../types').UnixFSEntry} UnixFSEntry
  * @typedef {import('../types').Resolver} Resolver
@@ -15,23 +15,24 @@ const errCode = require('err-code')
  * @type {{ [ key: string ]: Resolver }}
  */
 const resolvers = {
-  'dag-pb': require('./unixfs-v1'),
-  raw: require('./raw'),
-  'dag-cbor': require('./dag-cbor'),
-  identity: require('./identity')
+  [multicodec.DAG_PB]: require('./unixfs-v1'),
+  [multicodec.RAW]: require('./raw'),
+  [multicodec.DAG_CBOR]: require('./dag-cbor'),
+  [multicodec.IDENTITY]: require('./identity')
 }
 
 /**
  * @type {Resolve}
  */
-function resolve (cid, name, path, toResolve, depth, ipld, options) {
-  const resolver = resolvers[cid.codec]
+function resolve (cid, name, path, toResolve, depth, blockService, options) {
+  const resolver = resolvers[cid.code]
 
   if (!resolver) {
-    throw errCode(new Error(`No resolver for codec ${cid.codec}`), 'ERR_NO_RESOLVER')
+    // @ts-ignore - A `CodecCode` is expected, but a number is just fine
+    throw errCode(new Error(`No resolver for codec ${multicodec.getName(cid.code)}`), 'ERR_NO_RESOLVER')
   }
 
-  return resolver(cid, name, path, toResolve, resolve, depth, ipld, options)
+  return resolver(cid, name, path, toResolve, resolve, depth, blockService, options)
 }
 
 module.exports = resolve

packages/ipfs-unixfs-exporter/src/resolvers/raw.js

@@ -30,23 +30,23 @@ const rawContent = (node) => {
 /**
  * @type {import('../types').Resolver}
  */
-const resolve = async (cid, name, path, toResolve, resolve, depth, ipld, options) => {
+const resolve = async (cid, name, path, toResolve, resolve, depth, blockService, options) => {
   if (toResolve.length) {
     throw errCode(new Error(`No link named ${path} found in raw node ${cid}`), 'ERR_NOT_FOUND')
   }
 
-  const buf = await ipld.get(cid, options)
+  const block = await blockService.get(cid, options)
 
   return {
     entry: {
       type: 'raw',
       name,
       path,
       cid,
-      content: rawContent(buf),
+      content: rawContent(block.bytes),
       depth,
-      size: buf.length,
-      node: buf
+      size: block.bytes.length,
+      node: block.bytes
     }
   }
 }

packages/ipfs-unixfs-exporter/src/resolvers/unixfs-v1/content/directory.js

@@ -9,7 +9,7 @@
 /**
  * @type {UnixfsV1Resolver}
  */
-const directoryContent = (cid, node, unixfs, path, resolve, depth, ipld) => {
+const directoryContent = (cid, node, unixfs, path, resolve, depth, blockService) => {
   /**
    * @param {ExporterOptions} [options]
    * @returns {UnixfsV1DirectoryContent}
@@ -20,7 +20,7 @@ const directoryContent = (cid, node, unixfs, path, resolve, depth, ipld) => {
     const links = node.Links.slice(offset, length)
 
     for (const link of links) {
-      const result = await resolve(link.Hash, link.Name, `${path}/${link.Name}`, [], depth + 1, ipld, options)
+      const result = await resolve(link.Hash, link.Name || '', `${path}/${link.Name || ''}`, [], depth + 1, blockService, options)
 
       if (result.entry) {
         yield result.entry