@libp2p/kad-dht 7.0.1 → 7.0.3

package/src/message/dht.ts

@@ -1,9 +1,12 @@
 /* eslint-disable import/export */
+/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
 
 import { encodeMessage, decodeMessage, message, enumeration } from 'protons-runtime'
-import type { Uint8ArrayList } from 'uint8arraylist'
 import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 export interface Record {
   key?: Uint8Array
@@ -18,38 +21,38 @@ export namespace Record {
 
   export const codec = (): Codec<Record> => {
     if (_codec == null) {
-      _codec = message<Record>((obj, writer, opts = {}) => {
+      _codec = message<Record>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.key != null) {
-          writer.uint32(10)
-          writer.bytes(obj.key)
+          w.uint32(10)
+          w.bytes(obj.key)
         }
 
         if (obj.value != null) {
-          writer.uint32(18)
-          writer.bytes(obj.value)
+          w.uint32(18)
+          w.bytes(obj.value)
         }
 
         if (obj.author != null) {
-          writer.uint32(26)
-          writer.bytes(obj.author)
+          w.uint32(26)
+          w.bytes(obj.author)
         }
 
         if (obj.signature != null) {
-          writer.uint32(34)
-          writer.bytes(obj.signature)
+          w.uint32(34)
+          w.bytes(obj.signature)
         }
 
         if (obj.timeReceived != null) {
-          writer.uint32(42)
-          writer.string(obj.timeReceived)
+          w.uint32(42)
+          w.string(obj.timeReceived)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {}
@@ -88,7 +91,7 @@ export namespace Record {
     return _codec
   }
 
-  export const encode = (obj: Record): Uint8Array => {
+  export const encode = (obj: Partial<Record>): Uint8Array => {
     return encodeMessage(obj, Record.codec())
   }
 
@@ -126,7 +129,7 @@ export namespace Message {
   }
 
   export namespace MessageType {
-    export const codec = () => {
+    export const codec = (): Codec<MessageType> => {
       return enumeration<MessageType>(__MessageTypeValues)
     }
   }
@@ -146,7 +149,7 @@ export namespace Message {
   }
 
   export namespace ConnectionType {
-    export const codec = () => {
+    export const codec = (): Codec<ConnectionType> => {
       return enumeration<ConnectionType>(__ConnectionTypeValues)
     }
   }
@@ -162,32 +165,30 @@ export namespace Message {
 
     export const codec = (): Codec<Peer> => {
       if (_codec == null) {
-        _codec = message<Peer>((obj, writer, opts = {}) => {
+        _codec = message<Peer>((obj, w, opts = {}) => {
           if (opts.lengthDelimited !== false) {
-            writer.fork()
+            w.fork()
           }
 
           if (obj.id != null) {
-            writer.uint32(10)
-            writer.bytes(obj.id)
+            w.uint32(10)
+            w.bytes(obj.id)
           }
 
           if (obj.addrs != null) {
             for (const value of obj.addrs) {
-              writer.uint32(18)
-              writer.bytes(value)
+              w.uint32(18)
+              w.bytes(value)
             }
-          } else {
-            throw new Error('Protocol error: required field "addrs" was not found in object')
           }
 
           if (obj.connection != null) {
-            writer.uint32(24)
-            Message.ConnectionType.codec().encode(obj.connection, writer)
+            w.uint32(24)
+            Message.ConnectionType.codec().encode(obj.connection, w)
           }
 
           if (opts.lengthDelimited !== false) {
-            writer.ldelim()
+            w.ldelim()
           }
         }, (reader, length) => {
           const obj: any = {
@@ -222,7 +223,7 @@ export namespace Message {
       return _codec
     }
 
-    export const encode = (obj: Peer): Uint8Array => {
+    export const encode = (obj: Partial<Peer>): Uint8Array => {
       return encodeMessage(obj, Peer.codec())
     }
 
@@ -235,51 +236,47 @@ export namespace Message {
 
   export const codec = (): Codec<Message> => {
     if (_codec == null) {
-      _codec = message<Message>((obj, writer, opts = {}) => {
+      _codec = message<Message>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.type != null) {
-          writer.uint32(8)
-          Message.MessageType.codec().encode(obj.type, writer)
+          w.uint32(8)
+          Message.MessageType.codec().encode(obj.type, w)
         }
 
         if (obj.clusterLevelRaw != null) {
-          writer.uint32(80)
-          writer.int32(obj.clusterLevelRaw)
+          w.uint32(80)
+          w.int32(obj.clusterLevelRaw)
         }
 
         if (obj.key != null) {
-          writer.uint32(18)
-          writer.bytes(obj.key)
+          w.uint32(18)
+          w.bytes(obj.key)
         }
 
         if (obj.record != null) {
-          writer.uint32(26)
-          writer.bytes(obj.record)
+          w.uint32(26)
+          w.bytes(obj.record)
         }
 
         if (obj.closerPeers != null) {
           for (const value of obj.closerPeers) {
-            writer.uint32(66)
-            Message.Peer.codec().encode(value, writer)
+            w.uint32(66)
+            Message.Peer.codec().encode(value, w)
           }
-        } else {
-          throw new Error('Protocol error: required field "closerPeers" was not found in object')
         }
 
         if (obj.providerPeers != null) {
           for (const value of obj.providerPeers) {
-            writer.uint32(74)
-            Message.Peer.codec().encode(value, writer)
+            w.uint32(74)
+            Message.Peer.codec().encode(value, w)
           }
-        } else {
-          throw new Error('Protocol error: required field "providerPeers" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -324,7 +321,7 @@ export namespace Message {
     return _codec
   }
 
-  export const encode = (obj: Message): Uint8Array => {
+  export const encode = (obj: Partial<Message>): Uint8Array => {
     return encodeMessage(obj, Message.codec())
   }
 

package/src/message/index.ts

@@ -42,7 +42,7 @@ export class Message {
   /**
    * @type {number}
    */
-  get clusterLevel () {
+  get clusterLevel (): number {
     const level = this.clusterLevelRaw - 1
     if (level < 0) {
       return 0
@@ -58,7 +58,7 @@ export class Message {
   /**
    * Encode into protobuf
    */
-  serialize () {
+  serialize (): Uint8Array {
     return PBMessage.encode({
       key: this.key,
       type: this.type,
@@ -72,7 +72,7 @@ export class Message {
   /**
    * Decode from protobuf
    */
-  static deserialize (raw: Uint8ArrayList | Uint8Array) {
+  static deserialize (raw: Uint8ArrayList | Uint8Array): Message {
     const dec = PBMessage.decode(raw)
 
     const msg = new Message(dec.type ?? PBMessage.MessageType.PUT_VALUE, dec.key ?? Uint8Array.from([]), dec.clusterLevelRaw ?? 0)
@@ -87,7 +87,7 @@ export class Message {
   }
 }
 
-function toPbPeer (peer: PeerInfo) {
+function toPbPeer (peer: PeerInfo): PBPeer {
   const output: PBPeer = {
     id: peer.id.toBytes(),
     addrs: (peer.multiaddrs ?? []).map((m) => m.bytes),
@@ -97,7 +97,7 @@ function toPbPeer (peer: PeerInfo) {
   return output
 }
 
-function fromPbPeer (peer: PBMessage.Peer) {
+function fromPbPeer (peer: PBMessage.Peer): PeerInfo {
   if (peer.id == null) {
     throw new Error('Invalid peer in message')
   }

package/src/network.ts

@@ -22,6 +22,7 @@ import type { Stream } from '@libp2p/interface-connection'
 import { abortableDuplex } from 'abortable-iterator'
 import type { Uint8ArrayList } from 'uint8arraylist'
 import type { KadDHTComponents } from './index.js'
+import type { QueryEvent } from '@libp2p/interface-dht'
 
 export interface NetworkInit {
   protocol: string
@@ -57,7 +58,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Start the network
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.running) {
       return
     }
@@ -68,21 +69,21 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Stop all network activity
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
   }
 
   /**
    * Is the network online?
    */
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Send a request and record RTT for latency measurements
    */
-  async * sendRequest (to: PeerId, msg: Message, options: AbortOptions = {}) {
+  async * sendRequest (to: PeerId, msg: Message, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       return
     }
@@ -118,7 +119,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Sends a message without expecting an answer
    */
-  async * sendMessage (to: PeerId, msg: Message, options: AbortOptions = {}) {
+  async * sendMessage (to: PeerId, msg: Message, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       return
     }
@@ -148,7 +149,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
   /**
    * Write a message to the given stream
    */
-  async _writeMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
+  async _writeMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<void> {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }
@@ -166,7 +167,7 @@ export class Network extends EventEmitter<NetworkEvents> implements Startable {
    * If no response is received after the specified timeout
    * this will error out.
    */
-  async _writeReadMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions) {
+  async _writeReadMessage (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>, msg: Uint8Array | Uint8ArrayList, options: AbortOptions): Promise<Message> {
     if (options.signal != null) {
       stream = abortableDuplex(stream, options.signal)
     }

package/src/peer-list/index.ts

@@ -13,7 +13,7 @@ export class PeerList {
   /**
    * Add a new peer. Returns `true` if it was a new one
    */
-  push (peerId: PeerId) {
+  push (peerId: PeerId): boolean {
     if (!this.has(peerId)) {
       this.list.push(peerId)
 
@@ -26,7 +26,7 @@ export class PeerList {
   /**
    * Check if this PeerInfo is already in here
    */
-  has (peerId: PeerId) {
+  has (peerId: PeerId): boolean {
     const match = this.list.find((i) => i.equals(peerId))
     return Boolean(match)
   }
@@ -34,21 +34,21 @@ export class PeerList {
   /**
    * Get the list as an array
    */
-  toArray () {
+  toArray (): PeerId[] {
     return this.list.slice()
   }
 
   /**
    * Remove the last element
    */
-  pop () {
+  pop (): PeerId | undefined {
     return this.list.pop()
   }
 
   /**
    * The length of the list
    */
-  get length () {
+  get length (): number {
     return this.list.length
   }
 }

package/src/peer-list/peer-distance-list.ts

@@ -33,21 +33,21 @@ export class PeerDistanceList {
   /**
    * The length of the list
    */
-  get length () {
+  get length (): number {
     return this.peerDistances.length
   }
 
   /**
    * The peerIds in the list, in order of distance from the origin key
    */
-  get peers () {
+  get peers (): PeerId[] {
     return this.peerDistances.map(pd => pd.peerId)
   }
 
   /**
    * Add a peerId to the list.
    */
-  async add (peerId: PeerId) {
+  async add (peerId: PeerId): Promise<void> {
     if (this.peerDistances.find(pd => pd.peerId.equals(peerId)) != null) {
       return
     }
@@ -67,7 +67,7 @@ export class PeerDistanceList {
    * Indicates whether any of the peerIds passed as a parameter are closer
    * to the origin key than the furthest peerId in the PeerDistanceList.
    */
-  async anyCloser (peerIds: PeerId[]) {
+  async anyCloser (peerIds: PeerId[]): Promise<boolean> {
     if (peerIds.length === 0) {
       return false
     }

package/src/peer-routing/index.ts

@@ -13,7 +13,7 @@ import { Libp2pRecord } from '@libp2p/record'
 import { logger } from '@libp2p/logger'
 import { keys } from '@libp2p/crypto'
 import { peerIdFromKeys } from '@libp2p/peer-id'
-import type { DHTRecord, QueryOptions, Validators } from '@libp2p/interface-dht'
+import type { DHTRecord, DialingPeerEvent, FinalPeerEvent, QueryEvent, QueryOptions, Validators } from '@libp2p/interface-dht'
 import type { RoutingTable } from '../routing-table/index.js'
 import type { QueryManager } from '../query/manager.js'
 import type { Network } from '../network.js'
@@ -97,7 +97,7 @@ export class PeerRouting {
   /**
    * Get a value via rpc call for the given parameters
    */
-  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: AbortOptions = {}) { // eslint-disable-line require-await
+  async * _getValueSingle (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     const msg = new Message(MESSAGE_TYPE.GET_VALUE, key, 0)
     yield * this.network.sendRequest(peer, msg, options)
   }
@@ -105,7 +105,7 @@ export class PeerRouting {
   /**
    * Get the public key directly from a node
    */
-  async * getPublicKeyFromNode (peer: PeerId, options: AbortOptions = {}) {
+  async * getPublicKeyFromNode (peer: PeerId, options: AbortOptions = {}): AsyncGenerator<QueryEvent> {
     const pkKey = utils.keyForPublicKey(peer)
 
     for await (const event of this._getValueSingle(peer, pkKey, options)) {
@@ -133,7 +133,7 @@ export class PeerRouting {
   /**
    * Search for a peer with the given ID
    */
-  async * findPeer (id: PeerId, options: QueryOptions = {}) {
+  async * findPeer (id: PeerId, options: QueryOptions = {}): AsyncGenerator<FinalPeerEvent | QueryEvent> {
     this.log('findPeer %p', id)
 
     // Try to find locally
@@ -215,14 +215,14 @@ export class PeerRouting {
    * Kademlia 'node lookup' operation on a key, which could be a the
    * bytes from a multihash or a peer ID
    */
-  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}) {
+  async * getClosestPeers (key: Uint8Array, options: QueryOptions = {}): AsyncGenerator<DialingPeerEvent | QueryEvent> {
     this.log('getClosestPeers to %b', key)
     const id = await utils.convertBuffer(key)
     const tablePeers = this.routingTable.closestPeers(id)
     const self = this // eslint-disable-line @typescript-eslint/no-this-alias
 
     const peers = new PeerDistanceList(id, this.routingTable.kBucketSize)
-    await Promise.all(tablePeers.map(async peer => await peers.add(peer)))
+    await Promise.all(tablePeers.map(async peer => { await peers.add(peer) }))
 
     const getCloserPeersQuery: QueryFunc = async function * ({ peer, signal }) {
       self.log('closerPeersSingle %s from %p', uint8ArrayToString(key, 'base32'), peer)
@@ -235,7 +235,7 @@ export class PeerRouting {
       yield event
 
       if (event.name === 'PEER_RESPONSE') {
-        await Promise.all(event.closer.map(async peerData => await peers.add(peerData.id)))
+        await Promise.all(event.closer.map(async peerData => { await peers.add(peerData.id) }))
       }
     }
 
@@ -259,7 +259,7 @@ export class PeerRouting {
    *
    * Note: The peerStore is updated with new addresses found for the given peer.
    */
-  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: AbortOptions = {}) {
+  async * getValueOrPeers (peer: PeerId, key: Uint8Array, options: AbortOptions = {}): AsyncGenerator<DialingPeerEvent | QueryEvent> {
     for await (const event of this._getValueSingle(peer, key, options)) {
       if (event.name === 'PEER_RESPONSE') {
         if (event.record != null) {
@@ -284,7 +284,7 @@ export class PeerRouting {
    * Verify a record, fetching missing public keys from the network.
    * Throws an error if the record is invalid.
    */
-  async _verifyRecordOnline (record: DHTRecord) {
+  async _verifyRecordOnline (record: DHTRecord): Promise<void> {
     if (record.timeReceived == null) {
       throw new CodeError('invalid record received', 'ERR_INVALID_RECORD')
     }
@@ -296,7 +296,7 @@ export class PeerRouting {
    * Get the nearest peers to the given query, but if closer
    * than self
    */
-  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId) {
+  async getCloserPeersOffline (key: Uint8Array, closerThan: PeerId): Promise<PeerInfo[]> {
     const id = await utils.convertBuffer(key)
     const ids = this.routingTable.closestPeers(id)
     const output: PeerInfo[] = []

package/src/providers.ts

@@ -66,14 +66,14 @@ export class Providers implements Startable {
     this.started = false
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.started
   }
 
   /**
    * Start the provider cleanup service
    */
-  async start () {
+  async start (): Promise<void> {
     if (this.started) {
       return
     }
@@ -93,7 +93,7 @@ export class Providers implements Startable {
   /**
    * Release any resources.
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.started = false
 
     if (this.cleaner != null) {
@@ -105,8 +105,8 @@ export class Providers implements Startable {
   /**
    * Check all providers if they are still valid, and if not delete them
    */
-  async _cleanup () {
-    return await this.syncQueue.add(async () => {
+  async _cleanup (): Promise<void> {
+    await this.syncQueue.add(async () => {
       const start = Date.now()
 
       let count = 0
@@ -174,7 +174,7 @@ export class Providers implements Startable {
   /**
    * Get the currently known provider peer ids for a given CID
    */
-  async _getProvidersMap (cid: CID) {
+  async _getProvidersMap (cid: CID): Promise<Map<string, Date>> {
     const cacheKey = makeProviderKey(cid)
     let provs: Map<string, Date> = this.cache.get(cacheKey)
 
@@ -189,8 +189,8 @@ export class Providers implements Startable {
   /**
    * Add a new provider for the given CID
    */
-  async addProvider (cid: CID, provider: PeerId) {
-    return await this.syncQueue.add(async () => {
+  async addProvider (cid: CID, provider: PeerId): Promise<void> {
+    await this.syncQueue.add(async () => {
       log('%p provides %s', provider, cid)
       const provs = await this._getProvidersMap(cid)
 
@@ -228,7 +228,7 @@ export class Providers implements Startable {
 /**
  * Encode the given key its matching datastore key
  */
-function makeProviderKey (cid: CID | string) {
+function makeProviderKey (cid: CID | string): string {
   const cidStr = typeof cid === 'string' ? cid : uint8ArrayToString(cid.multihash.bytes, 'base32')
 
   return `${PROVIDER_KEY_PREFIX}/${cidStr}`
@@ -237,7 +237,7 @@ function makeProviderKey (cid: CID | string) {
 /**
  * Write a provider into the given store
  */
-async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, time: Date) { // eslint-disable-line require-await
+async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, time: Date): Promise<void> {
   const dsKey = [
     makeProviderKey(cid),
     '/',
@@ -247,13 +247,13 @@ async function writeProviderEntry (store: Datastore, cid: CID, peer: PeerId, tim
   const key = new Key(dsKey)
   const buffer = Uint8Array.from(varint.encode(time.getTime()))
 
-  return await store.put(key, buffer)
+  await store.put(key, buffer)
 }
 
 /**
  * Parse the CID and provider peer id from the key
  */
-function parseProviderKey (key: Key) {
+function parseProviderKey (key: Key): { cid: string, peerId: string } {
   const parts = key.toString().split('/')
 
   if (parts.length !== 5) {
@@ -269,7 +269,7 @@ function parseProviderKey (key: Key) {
 /**
  * Load providers for the given CID from the store
  */
-async function loadProviders (store: Datastore, cid: CID) {
+async function loadProviders (store: Datastore, cid: CID): Promise<Map<string, Date>> {
   const providers = new Map<string, Date>()
   const query = store.query({ prefix: makeProviderKey(cid) })
 
@@ -281,6 +281,6 @@ async function loadProviders (store: Datastore, cid: CID) {
   return providers
 }
 
-function readTime (buf: Uint8Array) {
+function readTime (buf: Uint8Array): Date {
   return new Date(varint.decode(buf))
 }

package/src/query/manager.ts

@@ -12,7 +12,7 @@ import { logger } from '@libp2p/logger'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { QueryFunc } from './types.js'
-import type { QueryOptions } from '@libp2p/interface-dht'
+import type { QueryEvent, QueryOptions } from '@libp2p/interface-dht'
 import { PeerSet } from '@libp2p/peer-collections'
 import type { Metric, Metrics } from '@libp2p/interface-metrics'
 
@@ -59,14 +59,14 @@ export class QueryManager implements Startable {
     this.queries = 0
   }
 
-  isStarted () {
+  isStarted (): boolean {
     return this.running
   }
 
   /**
    * Starts the query manager
    */
-  async start () {
+  async start (): Promise<void> {
     this.running = true
 
     if (this.components.metrics != null && this.metrics == null) {
@@ -80,7 +80,7 @@ export class QueryManager implements Startable {
   /**
    * Stops all queries
    */
-  async stop () {
+  async stop (): Promise<void> {
     this.running = false
 
     for (const controller of this.controllers) {
@@ -90,7 +90,7 @@ export class QueryManager implements Startable {
     this.controllers.clear()
   }
 
-  async * run (key: Uint8Array, peers: PeerId[], queryFunc: QueryFunc, options: QueryOptions = {}) {
+  async * run (key: Uint8Array, peers: PeerId[], queryFunc: QueryFunc, options: QueryOptions = {}): AsyncGenerator<QueryEvent> {
     if (!this.running) {
       throw new Error('QueryManager not started')
     }

package/src/query/query-path.ts

@@ -83,7 +83,7 @@ export interface QueryPathOptions {
  * Walks a path through the DHT, calling the passed query function for
  * every peer encountered that we have not seen before
  */
-export async function * queryPath (options: QueryPathOptions) {
+export async function * queryPath (options: QueryPathOptions): AsyncGenerator<QueryEvent, void, undefined> {
   const { key, startingPeer, ourPeerId, signal, query, alpha, pathIndex, numPaths, cleanUp, queryFuncTimeout, log, peersSeen } = options
   // Only ALPHA node/value lookups are allowed at any given time for each process
   // https://github.com/libp2p/specs/tree/master/kad-dht#alpha-concurrency-parameter-%CE%B1
@@ -98,7 +98,7 @@ export async function * queryPath (options: QueryPathOptions) {
    * Adds the passed peer to the query queue if it's not us and no
    * other path has passed through this peer
    */
-  function queryPeer (peer: PeerId, peerKadId: Uint8Array) {
+  function queryPeer (peer: PeerId, peerKadId: Uint8Array): void {
     if (peer == null) {
       return
     }
@@ -196,12 +196,12 @@ export async function * queryPath (options: QueryPathOptions) {
   yield * toGenerator(queue, signal, cleanUp, log)
 }
 
-async function * toGenerator (queue: Queue, signal: AbortSignal, cleanUp: EventEmitter<CleanUpEvents>, log: Logger) {
+async function * toGenerator (queue: Queue, signal: AbortSignal, cleanUp: EventEmitter<CleanUpEvents>, log: Logger): AsyncGenerator<QueryEvent, void, undefined> {
   let deferred = defer()
   let running = true
   const results: QueryEvent[] = []
 
-  const cleanup = () => {
+  const cleanup = (): void => {
     if (!running) {
       return
     }