feat: convert to typescript (#1172)

Converts this module to typescript.

- Ecosystem modules renamed from (e.g.) `libp2p-tcp` to `@libp2p/tcp`
- Ecosystem module now have named exports
- Configuration has been updated, now pass instances of modules instead of classes:
- Some configuration keys have been renamed to make them more descriptive.  `transport` -> `transports`, `connEncryption` -> `connectionEncryption`.  In general where we pass multiple things, the key is now plural, e.g. `streamMuxer` -> `streamMuxers`, `contentRouting` -> `contentRouters`, etc.  Where we are configuring a singleton the config key is singular, e.g. `connProtector` -> `connectionProtector` etc.
- Properties of the `modules` config key have been moved to the root
- Properties of the `config` config key have been moved to the root
```js
// before
import Libp2p from 'libp2p'
import TCP from 'libp2p-tcp'

await Libp2p.create({
  modules: {
    transport: [
      TCP
    ],
  }
  config: {
    transport: {
      [TCP.tag]: {
        foo: 'bar'
      }
    },
    relay: {
      enabled: true,
      hop: {
        enabled: true,
        active: true
      }
    }
  }
})
```
```js
// after
import { createLibp2p } from 'libp2p'
import { TCP } from '@libp2p/tcp'

await createLibp2p({
  transports: [
    new TCP({ foo: 'bar' })
  ],
  relay: {
    enabled: true,
    hop: {
      enabled: true,
      active: true
    }
  }
})
```
- Use of `enabled` flag has been reduced - previously you could pass a module but disable it with config.  Now if you don't want a feature, just don't pass an implementation.   Eg:
```js
// before
await Libp2p.create({
  modules: {
    transport: [
      TCP
    ],
    pubsub: Gossipsub
  },
  config: {
    pubsub: {
      enabled: false
    }
  }
})
```
```js
// after
await createLibp2p({
  transports: [
    new TCP()
  ]
})
```
- `.multiaddrs` renamed to `.getMultiaddrs()` because it's not a property accessor, work is done by that method to calculate announce addresses, observed addresses, etc
- `/p2p/${peerId}` is now appended to all addresses returned by `.getMultiaddrs()` so they can be used opaquely (every consumer has to append the peer ID to the address to actually use it otherwise).  If you need low-level unadulterated addresses, call methods on the address manager.

BREAKING CHANGE: types are no longer hand crafted, this module is now ESM only

test/fetch/fetch.node.ts

@@ -0,0 +1,190 @@
+/* eslint-env mocha */
+
+import { expect } from 'aegir/utils/chai.js'
+import { createLibp2pNode, Libp2pNode } from '../../src/libp2p.js'
+import { TCP } from '@libp2p/tcp'
+import { Mplex } from '@libp2p/mplex'
+import { NOISE } from '@chainsafe/libp2p-noise'
+import { createPeerId } from '../utils/creators/peer.js'
+import { codes } from '../../src/errors.js'
+import type { PeerId } from '@libp2p/interfaces/peer-id'
+
+async function createNode (peerId: PeerId) {
+  return await createLibp2pNode({
+    peerId,
+    addresses: {
+      listen: ['/ip4/0.0.0.0/tcp/0']
+    },
+    transports: [
+      new TCP()
+    ],
+    streamMuxers: [
+      new Mplex()
+    ],
+    connectionEncryption: [
+      NOISE
+    ]
+  })
+}
+
+describe('Fetch', () => {
+  let sender: Libp2pNode
+  let receiver: Libp2pNode
+  const PREFIX_A = '/moduleA/'
+  const PREFIX_B = '/moduleB/'
+  const DATA_A = { foobar: 'hello world' }
+  const DATA_B = { foobar: 'goodnight moon' }
+
+  const generateLookupFunction = function (prefix: string, data: Record<string, string>) {
+    return async function (key: string): Promise<Uint8Array | null> {
+      key = key.slice(prefix.length) // strip prefix from key
+      const val = data[key]
+      if (val != null) {
+        return (new TextEncoder()).encode(val)
+      }
+      return null
+    }
+  }
+
+  beforeEach(async () => {
+    const peerIdA = await createPeerId()
+    const peerIdB = await createPeerId()
+    sender = await createNode(peerIdA)
+    receiver = await createNode(peerIdB)
+
+    await sender.start()
+    await receiver.start()
+
+    await Promise.all([
+      ...sender.getMultiaddrs().map(async addr => await receiver.dial(addr)),
+      ...receiver.getMultiaddrs().map(async addr => await sender.dial(addr))
+    ])
+  })
+
+  afterEach(async () => {
+    receiver.fetchService.unregisterLookupFunction(PREFIX_A)
+    receiver.fetchService.unregisterLookupFunction(PREFIX_B)
+
+    await sender.stop()
+    await receiver.stop()
+  })
+
+  it('fetch key that exists in receivers datastore', async () => {
+    receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_A))
+
+    const rawData = await sender.fetch(receiver.peerId, '/moduleA/foobar')
+
+    if (rawData == null) {
+      throw new Error('Value was not found')
+    }
+
+    const value = (new TextDecoder()).decode(rawData)
+    expect(value).to.equal('hello world')
+  })
+
+  it('Different lookups for different prefixes', async () => {
+    receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_A))
+    receiver.fetchService.registerLookupFunction(PREFIX_B, generateLookupFunction(PREFIX_B, DATA_B))
+
+    const rawDataA = await sender.fetch(receiver.peerId, '/moduleA/foobar')
+
+    if (rawDataA == null) {
+      throw new Error('Value was not found')
+    }
+
+    const valueA = (new TextDecoder()).decode(rawDataA)
+    expect(valueA).to.equal('hello world')
+
+    // Different lookup functions can be registered on different prefixes, and have different
+    // values for the same key underneath the different prefix.
+    const rawDataB = await sender.fetch(receiver.peerId, '/moduleB/foobar')
+
+    if (rawDataB == null) {
+      throw new Error('Value was not found')
+    }
+
+    const valueB = (new TextDecoder()).decode(rawDataB)
+    expect(valueB).to.equal('goodnight moon')
+  })
+
+  it('fetch key that does not exist in receivers datastore', async () => {
+    receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_A))
+    const result = await sender.fetch(receiver.peerId, '/moduleA/garbage')
+
+    expect(result).to.equal(null)
+  })
+
+  it('fetch key with unknown prefix throws error', async () => {
+    receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_A))
+
+    await expect(sender.fetch(receiver.peerId, '/moduleUNKNOWN/foobar'))
+      .to.eventually.be.rejected.with.property('code', codes.ERR_INVALID_PARAMETERS)
+  })
+
+  it('registering multiple handlers for same prefix errors', async () => {
+    receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_A))
+
+    expect(() => receiver.fetchService.registerLookupFunction(PREFIX_A, generateLookupFunction(PREFIX_A, DATA_B)))
+      .to.throw().with.property('code', codes.ERR_KEY_ALREADY_EXISTS)
+  })
+
+  it('can unregister handler', async () => {
+    const lookupFunction = generateLookupFunction(PREFIX_A, DATA_A)
+    receiver.fetchService.registerLookupFunction(PREFIX_A, lookupFunction)
+    const rawDataA = await sender.fetch(receiver.peerId, '/moduleA/foobar')
+
+    if (rawDataA == null) {
+      throw new Error('Value was not found')
+    }
+
+    const valueA = (new TextDecoder()).decode(rawDataA)
+    expect(valueA).to.equal('hello world')
+
+    receiver.fetchService.unregisterLookupFunction(PREFIX_A, lookupFunction)
+
+    await expect(sender.fetch(receiver.peerId, '/moduleA/foobar'))
+      .to.eventually.be.rejectedWith(/No lookup function registered for key/)
+  })
+
+  it('can unregister all handlers', async () => {
+    const lookupFunction = generateLookupFunction(PREFIX_A, DATA_A)
+    receiver.fetchService.registerLookupFunction(PREFIX_A, lookupFunction)
+    const rawDataA = await sender.fetch(receiver.peerId, '/moduleA/foobar')
+
+    if (rawDataA == null) {
+      throw new Error('Value was not found')
+    }
+
+    const valueA = (new TextDecoder()).decode(rawDataA)
+    expect(valueA).to.equal('hello world')
+
+    receiver.fetchService.unregisterLookupFunction(PREFIX_A)
+
+    await expect(sender.fetch(receiver.peerId, '/moduleA/foobar'))
+      .to.eventually.be.rejectedWith(/No lookup function registered for key/)
+  })
+
+  it('does not unregister wrong handlers', async () => {
+    const lookupFunction = generateLookupFunction(PREFIX_A, DATA_A)
+    receiver.fetchService.registerLookupFunction(PREFIX_A, lookupFunction)
+    const rawDataA = await sender.fetch(receiver.peerId, '/moduleA/foobar')
+
+    if (rawDataA == null) {
+      throw new Error('Value was not found')
+    }
+
+    const valueA = (new TextDecoder()).decode(rawDataA)
+    expect(valueA).to.equal('hello world')
+
+    receiver.fetchService.unregisterLookupFunction(PREFIX_A, async () => { return null })
+
+    const rawDataB = await sender.fetch(receiver.peerId, '/moduleA/foobar')
+
+    if (rawDataB == null) {
+      throw new Error('Value was not found')
+    }
+
+    const valueB = (new TextDecoder()).decode(rawDataB)
+    expect(valueB).to.equal('hello world')
+  })
+})