chore: allow disabling dht and make sure we have an ipns datastore available

Author: achingbrain

packages/interface-ipfs-core/package.json

@@ -91,6 +91,7 @@
     "it-to-buffer": "^2.0.0",
     "libp2p-crypto": "^0.21.1",
     "libp2p-websockets": "^0.16.2",
+    "merge-options": "^3.0.4",
     "multiaddr": "^10.0.0",
     "multiformats": "^9.4.13",
     "nanoid": "^3.1.23",

packages/interface-ipfs-core/src/miscellaneous/resolve.js

@@ -32,13 +32,16 @@ export function testResolve (factory, options) {
     let ipfsId
 
     before(async () => {
-      ipfs = (await factory.spawn({ type: 'proc', ipfsOptions: merge(ipfsOptions, {
-        config: {
-          Routing: {
-            Type: 'none'
+      ipfs = (await factory.spawn({
+        type: 'proc',
+        ipfsOptions: merge(ipfsOptions, {
+          config: {
+            Routing: {
+              Type: 'none'
+            }
           }
-        }
-      })})).api
+        })
+      })).api
       ipfsId = await ipfs.id()
     })
 
@@ -104,13 +107,16 @@ export function testResolve (factory, options) {
       // @ts-ignore this is mocha
       this.timeout(20 * 1000)
       // webworkers are not dialable because webrtc is not available
-      const node = (await factory.spawn({ type: isWebWorker ? 'go' : undefined, ipfsOptions: {
-        config: {
-          Routing: {
-            Type: 'none'
+      const node = (await factory.spawn({
+        type: isWebWorker ? 'go' : undefined,
+        ipfsOptions: {
+          config: {
+            Routing: {
+              Type: 'none'
+            }
           }
         }
-      } })).api
+      })).api
       const nodeId = await node.id()
       await ipfs.swarm.connect(nodeId.addresses[0])
       const { path } = await ipfs.add(uint8ArrayFromString('should resolve a record recursive === true'))
@@ -127,13 +133,16 @@ export function testResolve (factory, options) {
       // @ts-ignore this is mocha
       this.timeout(20 * 1000)
       // webworkers are not dialable because webrtc is not available
-      const node = (await factory.spawn({ type: isWebWorker ? 'go' : undefined, ipfsOptions: {
-        config: {
-          Routing: {
-            Type: 'none'
+      const node = (await factory.spawn({
+        type: isWebWorker ? 'go' : undefined,
+        ipfsOptions: {
+          config: {
+            Routing: {
+              Type: 'none'
+            }
           }
         }
-      } })).api
+      })).api
       const nodeId = await node.id()
       await ipfs.swarm.connect(nodeId.addresses[0])
       const { path } = await ipfs.add(uint8ArrayFromString('should resolve an IPNS key if recursive === false'))

packages/ipfs-core/src/components/libp2p.js

@@ -32,6 +32,7 @@ const mergeOptions = mergeOpts.bind({ ignoreUndefined: true })
  * @typedef {import('../types').Options} IPFSOptions
  * @typedef {import('libp2p')} LibP2P
  * @typedef {import('libp2p').Libp2pOptions & import('libp2p').CreateOptions} Libp2pOptions
+ * @typedef {import('libp2p').Libp2pConfig} Libp2pConfig
  * @typedef {import('ipfs-core-types/src/config').Config} IPFSConfig
  */
 
@@ -128,7 +129,7 @@ function getLibp2pOptions ({ options, config, datastore, keys, keychainConfig, p
         }
       },
       dht: {
-        enabled: get(config, 'Routing.Type', 'none') !== 'none',
+        enabled: get(config, 'Routing.Type', 'dhtclient') !== 'none',
         clientMode: get(config, 'Routing.Type', 'dht') !== 'dhtserver',
         kBucketSize: get(options, 'dht.kBucketSize', 20),
         validators: {

packages/ipfs-core/src/ipns/routing/config.js

@@ -30,12 +30,15 @@ export function createRouting ({ libp2p, repo, peerId, options }) {
     ipnsStores.push(pubsubDs)
   }
 
-  // DHT should not be added as routing if we are offline or it is disabled
-  if (get(options, 'offline') || get(options, 'config.Routing.Type', 'none') === 'none') {
+  // Add DHT datastore if enabled
+  if (!get(options, 'offline', false) && libp2p._config && libp2p._config.dht && libp2p._config.dht.enabled) {
+    ipnsStores.push(new DHTDatastore(libp2p._dht))
+  }
+
+  // Add an offline datastore if we are offline or no other datastores are configured
+  if (get(options, 'offline', false) || ipnsStores.length === 0) {
     const offlineDatastore = new OfflineDatastore(repo)
     ipnsStores.push(offlineDatastore)
-  } else {
-    ipnsStores.push(new DHTDatastore(libp2p._dht))
   }
 
   // Create ipns routing with a set of datastores

packages/ipfs-core/test/name.spec.js

@@ -157,7 +157,7 @@ describe('name', function () {
       // @ts-expect-error invalid argument
       await expect(publisher.publish(peerId.privKey, ipfsRef))
         .to.eventually.be.rejected()
-        .with.property('code', 'ERR_STORING_IN_DATASTORE')
+        .with.property('code', 'ERR_CREATING_IPNS_RECORD')
     })
   })
 
@@ -283,17 +283,16 @@ describe('name', function () {
         }
       })
 
-      expect(config.stores).to.have.lengthOf(2)
+      expect(config.stores).to.have.lengthOf(1)
       expect(config.stores[0] instanceof IpnsPubsubDatastore).to.eql(true)
-      expect(config.stores[1] instanceof OfflineDatastore).to.eql(true)
     })
 
     it('should use the dht if enabled', () => {
       const dht = sinon.stub()
 
       const config = createRouting({
         // @ts-expect-error sinon.stub() is not complete implementation
-        libp2p: { _dht: dht },
+        libp2p: { _dht: dht, _config: { dht: { enabled: true } } },
         // @ts-expect-error sinon.stub() is not complete implementation
         repo: sinon.stub(),
         // @ts-expect-error sinon.stub() is not complete implementation