@libp2p/peer-store 4.0.0 → 5.0.1

package/src/index.ts

@@ -7,39 +7,40 @@ import { PeerStoreProtoBook } from './proto-book.js'
 import { PersistentStore, Store } from './store.js'
 import type { PeerStore, AddressBook, KeyBook, MetadataBook, ProtoBook, PeerStoreEvents, PeerStoreInit, Peer, TagOptions } from '@libp2p/interface-peer-store'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { Components, Initializable } from '@libp2p/components'
 import errCode from 'err-code'
 import { Tag, Tags } from './pb/tags.js'
+import type { Datastore } from 'interface-datastore'
 
 const log = logger('libp2p:peer-store')
 
+export interface PersistentPeerStoreComponents {
+  peerId: PeerId
+  datastore: Datastore
+}
+
 /**
  * An implementation of PeerStore that stores data in a Datastore
  */
-export class PersistentPeerStore extends EventEmitter<PeerStoreEvents> implements PeerStore, Initializable {
+export class PersistentPeerStore extends EventEmitter<PeerStoreEvents> implements PeerStore {
   public addressBook: AddressBook
   public keyBook: KeyBook
   public metadataBook: MetadataBook
   public protoBook: ProtoBook
 
-  private components: Components = new Components()
+  private readonly components: PersistentPeerStoreComponents
   private readonly store: Store
 
-  constructor (init: PeerStoreInit = {}) {
+  constructor (components: PersistentPeerStoreComponents, init: PeerStoreInit = {}) {
     super()
 
-    this.store = new PersistentStore()
+    this.components = components
+    this.store = new PersistentStore(components)
     this.addressBook = new PeerStoreAddressBook(this.dispatchEvent.bind(this), this.store, init.addressFilter)
     this.keyBook = new PeerStoreKeyBook(this.dispatchEvent.bind(this), this.store)
     this.metadataBook = new PeerStoreMetadataBook(this.dispatchEvent.bind(this), this.store)
     this.protoBook = new PeerStoreProtoBook(this.dispatchEvent.bind(this), this.store)
   }
 
-  init (components: Components) {
-    this.components = components
-    ;(this.store as PersistentStore).init(components)
-  }
-
   async forEach (fn: (peer: Peer) => void) {
     log.trace('getPeers await read lock')
     const release = await this.store.lock.readLock()
@@ -47,7 +48,7 @@ export class PersistentPeerStore extends EventEmitter<PeerStoreEvents> implement
 
     try {
       for await (const peer of this.store.all()) {
-        if (peer.id.equals(this.components.getPeerId())) {
+        if (peer.id.equals(this.components.peerId)) {
           // Skip self peer if present
           continue
         }

package/src/pb/peer.ts

@@ -1,5 +1,7 @@
 /* eslint-disable import/export */
+/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 
 import { encodeMessage, decodeMessage, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -18,50 +20,48 @@ export namespace Peer {
 
   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.addresses != null) {
           for (const value of obj.addresses) {
-            writer.uint32(10)
-            Address.codec().encode(value, writer)
+            w.uint32(10)
+            Address.codec().encode(value, w, {
+              writeDefaults: true
+            })
           }
-        } else {
-          throw new Error('Protocol error: required field "addresses" was not found in object')
         }
 
         if (obj.protocols != null) {
           for (const value of obj.protocols) {
-            writer.uint32(18)
-            writer.string(value)
+            w.uint32(18)
+            w.string(value)
           }
-        } else {
-          throw new Error('Protocol error: required field "protocols" was not found in object')
         }
 
         if (obj.metadata != null) {
           for (const value of obj.metadata) {
-            writer.uint32(26)
-            Metadata.codec().encode(value, writer)
+            w.uint32(26)
+            Metadata.codec().encode(value, w, {
+              writeDefaults: true
+            })
           }
-        } else {
-          throw new Error('Protocol error: required field "metadata" was not found in object')
         }
 
         if (obj.pubKey != null) {
-          writer.uint32(34)
-          writer.bytes(obj.pubKey)
+          w.uint32(34)
+          w.bytes(obj.pubKey)
         }
 
         if (obj.peerRecordEnvelope != null) {
-          writer.uint32(42)
-          writer.bytes(obj.peerRecordEnvelope)
+          w.uint32(42)
+          w.bytes(obj.peerRecordEnvelope)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -123,25 +123,23 @@ export namespace Address {
 
   export const codec = (): Codec<Address> => {
     if (_codec == null) {
-      _codec = message<Address>((obj, writer, opts = {}) => {
+      _codec = message<Address>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
-        if (obj.multiaddr != null) {
-          writer.uint32(10)
-          writer.bytes(obj.multiaddr)
-        } else {
-          throw new Error('Protocol error: required field "multiaddr" was not found in object')
+        if (opts.writeDefaults === true || (obj.multiaddr != null && obj.multiaddr.byteLength > 0)) {
+          w.uint32(10)
+          w.bytes(obj.multiaddr)
         }
 
         if (obj.isCertified != null) {
-          writer.uint32(16)
-          writer.bool(obj.isCertified)
+          w.uint32(16)
+          w.bool(obj.isCertified)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -166,10 +164,6 @@ export namespace Address {
           }
         }
 
-        if (obj.multiaddr == null) {
-          throw new Error('Protocol error: value for required field "multiaddr" was not found in protobuf')
-        }
-
         return obj
       })
     }
@@ -196,27 +190,23 @@ export namespace Metadata {
 
   export const codec = (): Codec<Metadata> => {
     if (_codec == null) {
-      _codec = message<Metadata>((obj, writer, opts = {}) => {
+      _codec = message<Metadata>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
-        if (obj.key != null) {
-          writer.uint32(10)
-          writer.string(obj.key)
-        } else {
-          throw new Error('Protocol error: required field "key" was not found in object')
+        if (opts.writeDefaults === true || obj.key !== '') {
+          w.uint32(10)
+          w.string(obj.key)
         }
 
-        if (obj.value != null) {
-          writer.uint32(18)
-          writer.bytes(obj.value)
-        } else {
-          throw new Error('Protocol error: required field "value" was not found in object')
+        if (opts.writeDefaults === true || (obj.value != null && obj.value.byteLength > 0)) {
+          w.uint32(18)
+          w.bytes(obj.value)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -242,14 +232,6 @@ export namespace Metadata {
           }
         }
 
-        if (obj.key == null) {
-          throw new Error('Protocol error: value for required field "key" was not found in protobuf')
-        }
-
-        if (obj.value == null) {
-          throw new Error('Protocol error: value for required field "value" was not found in protobuf')
-        }
-
         return obj
       })
     }

package/src/pb/tags.ts

@@ -1,5 +1,7 @@
 /* eslint-disable import/export */
+/* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
 
 import { encodeMessage, decodeMessage, message } from 'protons-runtime'
 import type { Uint8ArrayList } from 'uint8arraylist'
@@ -14,22 +16,22 @@ export namespace Tags {
 
   export const codec = (): Codec<Tags> => {
     if (_codec == null) {
-      _codec = message<Tags>((obj, writer, opts = {}) => {
+      _codec = message<Tags>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
         if (obj.tags != null) {
           for (const value of obj.tags) {
-            writer.uint32(10)
-            Tag.codec().encode(value, writer)
+            w.uint32(10)
+            Tag.codec().encode(value, w, {
+              writeDefaults: true
+            })
           }
-        } else {
-          throw new Error('Protocol error: required field "tags" was not found in object')
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -78,30 +80,28 @@ export namespace Tag {
 
   export const codec = (): Codec<Tag> => {
     if (_codec == null) {
-      _codec = message<Tag>((obj, writer, opts = {}) => {
+      _codec = message<Tag>((obj, w, opts = {}) => {
         if (opts.lengthDelimited !== false) {
-          writer.fork()
+          w.fork()
         }
 
-        if (obj.name != null) {
-          writer.uint32(10)
-          writer.string(obj.name)
-        } else {
-          throw new Error('Protocol error: required field "name" was not found in object')
+        if (opts.writeDefaults === true || obj.name !== '') {
+          w.uint32(10)
+          w.string(obj.name)
         }
 
         if (obj.value != null) {
-          writer.uint32(16)
-          writer.uint32(obj.value)
+          w.uint32(16)
+          w.uint32(obj.value)
         }
 
         if (obj.expiry != null) {
-          writer.uint32(24)
-          writer.uint64(obj.expiry)
+          w.uint32(24)
+          w.uint64(obj.expiry)
         }
 
         if (opts.lengthDelimited !== false) {
-          writer.ldelim()
+          w.ldelim()
         }
       }, (reader, length) => {
         const obj: any = {
@@ -129,10 +129,6 @@ export namespace Tag {
           }
         }
 
-        if (obj.name == null) {
-          throw new Error('Protocol error: value for required field "name" was not found in protobuf')
-        }
-
         return obj
       })
     }

package/src/store.ts

@@ -10,7 +10,7 @@ import mortice from 'mortice'
 import { equals as uint8arrayEquals } from 'uint8arrays/equals'
 import type { Peer } from '@libp2p/interface-peer-store'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { Components } from '@libp2p/components'
+import type { PersistentPeerStoreComponents } from './index.js'
 
 const log = logger('libp2p:peer-store:store')
 
@@ -34,20 +34,17 @@ export interface Store {
 }
 
 export class PersistentStore {
-  private components: Components = new Components()
+  private readonly components: PersistentPeerStoreComponents
   public lock: any
 
-  constructor () {
+  constructor (components: PersistentPeerStoreComponents) {
+    this.components = components
     this.lock = mortice({
       name: 'peer-store',
       singleProcess: true
     })
   }
 
-  init (components: Components) {
-    this.components = components
-  }
-
   _peerIdToDatastoreKey (peerId: PeerId) {
     if (peerId.type == null) {
       log.error('peerId must be an instance of peer-id to store data')
@@ -59,15 +56,15 @@ export class PersistentStore {
   }
 
   async has (peerId: PeerId) {
-    return await this.components.getDatastore().has(this._peerIdToDatastoreKey(peerId))
+    return await this.components.datastore.has(this._peerIdToDatastoreKey(peerId))
   }
 
   async delete (peerId: PeerId) {
-    await this.components.getDatastore().delete(this._peerIdToDatastoreKey(peerId))
+    await this.components.datastore.delete(this._peerIdToDatastoreKey(peerId))
   }
 
   async load (peerId: PeerId): Promise<Peer> {
-    const buf = await this.components.getDatastore().get(this._peerIdToDatastoreKey(peerId))
+    const buf = await this.components.datastore.get(this._peerIdToDatastoreKey(peerId))
     const peer = PeerPB.decode(buf)
     const metadata = new Map()
 
@@ -133,7 +130,7 @@ export class PersistentStore {
       peerRecordEnvelope: peer.peerRecordEnvelope
     })
 
-    await this.components.getDatastore().put(this._peerIdToDatastoreKey(peer.id), buf.subarray())
+    await this.components.datastore.put(this._peerIdToDatastoreKey(peer.id), buf.subarray())
 
     return await this.load(peer.id)
   }
@@ -231,7 +228,7 @@ export class PersistentStore {
   }
 
   async * all () {
-    for await (const key of this.components.getDatastore().queryKeys({
+    for await (const key of this.components.datastore.queryKeys({
       prefix: NAMESPACE_COMMON
     })) {
       // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}