@libp2p/peer-store 8.1.4 → 8.2.1-05abd49f

package/src/index.ts

@@ -1,10 +1,11 @@
 import { logger } from '@libp2p/logger'
 import { RecordEnvelope, PeerRecord } from '@libp2p/peer-record'
+import all from 'it-all'
 import { PersistentStore, type PeerUpdate } from './store.js'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore, Peer, PeerData } from '@libp2p/interface-peer-store'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore, Peer, PeerData, PeerQuery } from '@libp2p/interface/peer-store'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { Datastore } from 'interface-datastore'
 
@@ -41,13 +42,13 @@ export class PersistentPeerStore implements PeerStore {
     this.store = new PersistentStore(components, init)
   }
 
-  async forEach (fn: (peer: Peer) => void): Promise<void> {
+  async forEach (fn: (peer: Peer,) => void, query?: PeerQuery): Promise<void> {
     log.trace('forEach await read lock')
     const release = await this.store.lock.readLock()
     log.trace('forEach got read lock')
 
     try {
-      for await (const peer of this.store.all()) {
+      for await (const peer of this.store.all(query)) {
         fn(peer)
       }
     } finally {
@@ -56,19 +57,13 @@ export class PersistentPeerStore implements PeerStore {
     }
   }
 
-  async all (): Promise<Peer[]> {
+  async all (query?: PeerQuery): Promise<Peer[]> {
     log.trace('all await read lock')
     const release = await this.store.lock.readLock()
     log.trace('all got read lock')
 
     try {
-      const output: Peer[] = []
-
-      for await (const peer of this.store.all()) {
-        output.push(peer)
-      }
-
-      return output
+      return await all(this.store.all(query))
     } finally {
       log.trace('all release read lock')
       release()

package/src/store.ts

@@ -1,4 +1,5 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { PeerMap } from '@libp2p/peer-collections'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import mortice, { type Mortice } from 'mortice'
 import { base32 } from 'multiformats/bases/base32'
@@ -9,10 +10,10 @@ import { bytesToPeer } from './utils/bytes-to-peer.js'
 import { NAMESPACE_COMMON, peerIdToDatastoreKey } from './utils/peer-id-to-datastore-key.js'
 import { toPeerPB } from './utils/to-peer-pb.js'
 import type { AddressFilter, PersistentPeerStoreComponents, PersistentPeerStoreInit } from './index.js'
-import type { PeerUpdate as PeerUpdateExternal } from '@libp2p/interface-libp2p'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Peer, PeerData } from '@libp2p/interface-peer-store'
-import type { Datastore } from 'interface-datastore'
+import type { PeerUpdate as PeerUpdateExternal } from '@libp2p/interface'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Peer, PeerData, PeerQuery } from '@libp2p/interface/peer-store'
+import type { Datastore, Key, Query } from 'interface-datastore'
 
 /**
  * Event detail emitted when peer data changes
@@ -21,6 +22,41 @@ export interface PeerUpdate extends PeerUpdateExternal {
   updated: boolean
 }
 
+function decodePeer (key: Key, value: Uint8Array, cache: PeerMap<Peer>): Peer {
+  // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}
+  const base32Str = key.toString().split('/')[2]
+  const buf = base32.decode(base32Str)
+  const peerId = peerIdFromBytes(buf)
+
+  const cached = cache.get(peerId)
+
+  if (cached != null) {
+    return cached
+  }
+
+  const peer = bytesToPeer(peerId, value)
+
+  cache.set(peerId, peer)
+
+  return peer
+}
+
+function mapQuery (query: PeerQuery, cache: PeerMap<Peer>): Query {
+  if (query == null) {
+    return {}
+  }
+
+  return {
+    prefix: NAMESPACE_COMMON,
+    filters: (query.filters ?? []).map(fn => ({ key, value }) => {
+      return fn(decodePeer(key, value, cache))
+    }),
+    orders: (query.orders ?? []).map(fn => (a, b) => {
+      return fn(decodePeer(a.key, a.value, cache), decodePeer(b.key, b.value, cache))
+    })
+  }
+}
+
 export class PersistentStore {
   private readonly peerId: PeerId
   private readonly datastore: Datastore
@@ -96,28 +132,25 @@ export class PersistentStore {
     return this.#saveIfDifferent(peerId, peerPb, existingBuf, existingPeer)
   }
 
-  async * all (): AsyncGenerator<Peer, void, unknown> {
-    for await (const { key, value } of this.datastore.query({
-      prefix: NAMESPACE_COMMON
-    })) {
-      // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}
-      const base32Str = key.toString().split('/')[2]
-      const buf = base32.decode(base32Str)
-      const peerId = peerIdFromBytes(buf)
+  async * all (query?: PeerQuery): AsyncGenerator<Peer, void, unknown> {
+    const peerCache = new PeerMap<Peer>()
+
+    for await (const { key, value } of this.datastore.query(mapQuery(query ?? {}, peerCache))) {
+      const peer = decodePeer(key, value, peerCache)
 
-      if (peerId.equals(this.peerId)) {
+      if (peer.id.equals(this.peerId)) {
         // Skip self peer if present
         continue
       }
 
-      yield bytesToPeer(peerId, value)
+      yield peer
     }
   }
 
   async #findExistingPeer (peerId: PeerId): Promise<{ existingBuf?: Uint8Array, existingPeer?: Peer }> {
     try {
       const existingBuf = await this.datastore.get(peerIdToDatastoreKey(peerId))
-      const existingPeer = await bytesToPeer(peerId, existingBuf)
+      const existingPeer = bytesToPeer(peerId, existingBuf)
 
       return {
         existingBuf,
@@ -137,7 +170,7 @@ export class PersistentStore {
 
     if (existingBuf != null && uint8ArrayEquals(buf, existingBuf)) {
       return {
-        peer: await bytesToPeer(peerId, buf),
+        peer: bytesToPeer(peerId, buf),
         previous: existingPeer,
         updated: false
       }
@@ -146,7 +179,7 @@ export class PersistentStore {
     await this.datastore.put(peerIdToDatastoreKey(peerId), buf)
 
     return {
-      peer: await bytesToPeer(peerId, buf),
+      peer: bytesToPeer(peerId, buf),
       previous: existingPeer,
       updated: true
     }

package/src/utils/bytes-to-peer.ts

@@ -1,15 +1,17 @@
-import { unmarshalPublicKey } from '@libp2p/crypto/keys'
-import { createFromPubKey } from '@libp2p/peer-id-factory'
+import { peerIdFromPeerId } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import { Peer as PeerPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Peer, Tag } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Peer, Tag } from '@libp2p/interface/peer-store'
 
-export async function bytesToPeer (peerId: PeerId, buf: Uint8Array): Promise<Peer> {
+export function bytesToPeer (peerId: PeerId, buf: Uint8Array): Peer {
   const peer = PeerPB.decode(buf)
 
   if (peer.publicKey != null && peerId.publicKey == null) {
-    peerId = await createFromPubKey(unmarshalPublicKey(peer.publicKey))
+    peerId = peerIdFromPeerId({
+      ...peerId,
+      publicKey: peerId.publicKey
+    })
   }
 
   const tags = new Map<string, Tag>()

package/src/utils/dedupe-addresses.ts

@@ -1,10 +1,10 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
 import { codes } from '../errors.js'
 import type { AddressFilter } from '../index.js'
 import type { Address as AddressPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Address } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Address } from '@libp2p/interface/peer-store'
 
 export async function dedupeFilterAndSortAddresses (peerId: PeerId, filter: AddressFilter, addresses: Array<Address | AddressPB | undefined>): Promise<AddressPB[]> {
   const addressMap = new Map<string, Address>()

package/src/utils/peer-data-to-datastore-peer.ts

@@ -1,11 +1,11 @@
 
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { isMultiaddr } from '@multiformats/multiaddr'
 import { equals as uint8arrayEquals } from 'uint8arrays/equals'
 import { codes } from '../errors.js'
 import type { Peer as PeerPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerData } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerData } from '@libp2p/interface/peer-store'
 
 export function toDatastorePeer (peerId: PeerId, data: PeerData): PeerPB {
   if (data == null) {

package/src/utils/peer-id-to-datastore-key.ts

@@ -1,5 +1,5 @@
-import { isPeerId, type PeerId } from '@libp2p/interface-peer-id'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { isPeerId, type PeerId } from '@libp2p/interface/peer-id'
 import { Key } from 'interface-datastore/key'
 import { codes } from '../errors.js'
 

package/src/utils/to-peer-pb.ts

@@ -1,11 +1,11 @@
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
 import { equals as uint8arrayEquals } from 'uint8arrays/equals'
 import { codes } from '../errors.js'
 import { dedupeFilterAndSortAddresses } from './dedupe-addresses.js'
 import type { AddressFilter } from '../index.js'
 import type { Tag, Peer as PeerPB } from '../pb/peer.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Address, Peer, PeerData, TagOptions } from '@libp2p/interface-peer-store'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Address, Peer, PeerData, TagOptions } from '@libp2p/interface/peer-store'
 
 export interface ToPBPeerOptions {
   addressFilter?: AddressFilter

package/dist/typedoc-urls.json

@@ -1,16 +0,0 @@
-{
-  "codec": "https://libp2p.github.io/js-libp2p-peer-store/functions/_internal_.Address.codec.html",
-  "decode": "https://libp2p.github.io/js-libp2p-peer-store/functions/_internal_.Address.decode.html",
-  "encode": "https://libp2p.github.io/js-libp2p-peer-store/functions/_internal_.Address.encode.html",
-  "Peer$metadataEntry": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/_internal_.Peer.Peer_metadataEntry-1.html",
-  "Peer$tagsEntry": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/_internal_.Peer.Peer_tagsEntry-1.html",
-  "PersistentStore": "https://libp2p.github.io/js-libp2p-peer-store/classes/_internal_.PersistentStore.html",
-  "Address": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/_internal_.Address-1.html",
-  "Peer": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/_internal_.Peer-1.html",
-  "PeerUpdate": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/_internal_.PeerUpdate.html",
-  "Tag": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/_internal_.Tag-1.html",
-  "PersistentPeerStore": "https://libp2p.github.io/js-libp2p-peer-store/classes/PersistentPeerStore.html",
-  "AddressFilter": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/AddressFilter.html",
-  "PersistentPeerStoreComponents": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/PersistentPeerStoreComponents.html",
-  "PersistentPeerStoreInit": "https://libp2p.github.io/js-libp2p-peer-store/interfaces/PersistentPeerStoreInit.html"
-}