@helia/utils 1.2.2 → 1.3.0-d43efc7

package/src/abstract-session.ts

@@ -1,12 +1,13 @@
 import { DEFAULT_SESSION_MIN_PROVIDERS, DEFAULT_SESSION_MAX_PROVIDERS, InsufficientProvidersError } from '@helia/interface'
-import { TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
+import { AbortError, TypedEventEmitter, setMaxListeners } from '@libp2p/interface'
 import { createScalableCuckooFilter } from '@libp2p/utils/filters'
 import { Queue } from '@libp2p/utils/queue'
 import { base64 } from 'multiformats/bases/base64'
 import pDefer from 'p-defer'
 import type { BlockBroker, BlockRetrievalOptions, CreateSessionOptions } from '@helia/interface'
-import type { AbortOptions, ComponentLogger, Logger } from '@libp2p/interface'
+import type { AbortOptions, ComponentLogger, Logger, PeerId } from '@libp2p/interface'
 import type { Filter } from '@libp2p/utils/filters'
+import type { Multiaddr } from '@multiformats/multiaddr'
 import type { CID } from 'multiformats/cid'
 import type { DeferredPromise } from 'p-defer'
 import type { ProgressEvent } from 'progress-events'
@@ -33,6 +34,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
   private readonly maxProviders: number
   public readonly providers: Provider[]
   private readonly evictionFilter: Filter
+  private readonly initialProviders: Array<PeerId | Multiaddr | Multiaddr[]>
 
   constructor (components: AbstractSessionComponents, init: AbstractCreateSessionOptions) {
     super()
@@ -46,6 +48,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
     this.maxProviders = init.maxProviders ?? DEFAULT_SESSION_MAX_PROVIDERS
     this.providers = []
     this.evictionFilter = createScalableCuckooFilter(this.maxProviders)
+    this.initialProviders = init.providers ?? []
   }
 
   async retrieve (cid: CID, options: BlockRetrievalOptions<RetrieveBlockProgressEvents> = {}): Promise<Uint8Array> {
@@ -97,6 +100,7 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
     })
     queue.addEventListener('idle', () => {
       if (foundBlock || options.signal?.aborted === true) {
+        this.log.trace('session idle, found block')
         // we either found the block or the user gave up
         return
       }
@@ -168,10 +172,18 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
         this.log.error('error retrieving session block for %c', cid, err)
       })
 
+    const signalAbortedListener = (): void => {
+      deferred.reject(new AbortError(options.signal?.reason ?? 'Session aborted'))
+      queue.abort()
+    }
+
+    options.signal?.addEventListener('abort', signalAbortedListener)
+
     try {
       return await deferred.promise
     } finally {
       this.removeEventListener('provider', peerAddedToSessionListener)
+      options.signal?.removeEventListener('abort', signalAbortedListener)
       queue.clear()
       this.requests.delete(cidStr)
     }
@@ -216,34 +228,83 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
       .then(async () => {
         this.log('finding %d-%d new provider(s) for %c', count, this.maxProviders, cid)
 
-        for await (const provider of this.findNewProviders(cid, options)) {
-          if (found === this.maxProviders || options.signal?.aborted === true) {
-            break
-          }
+        // process any specific providers for this session
+        if (this.initialProviders.length > 0) {
+          while (found < count && this.initialProviders.length > 0) {
+            const prov = this.initialProviders.pop()
 
-          if (this.hasProvider(provider)) {
-            continue
-          }
+            if (prov == null) {
+              break
+            }
+
+            const provider = await this.convertToProvider(prov, options)
+
+            if (options.signal?.aborted === true) {
+              break
+            }
 
-          this.log('found %d/%d new providers', found, this.maxProviders)
-          this.providers.push(provider)
+            if (provider == null) {
+              continue
+            }
+
+            if (this.hasProvider(provider)) {
+              continue
+            }
 
-          // let the new peer join current queries
-          this.safeDispatchEvent('provider', {
-            detail: provider
-          })
+            this.log('found %d/%d new providers', found, this.maxProviders)
+            this.providers.push(provider)
 
-          found++
+            // let the new peer join current queries
+            this.safeDispatchEvent('provider', {
+              detail: provider
+            })
 
-          if (found === count) {
-            this.log('session is ready')
-            deferred.resolve()
-            // continue finding peers until we reach this.maxProviders
+            found++
+
+            if (found === count) {
+              this.log('session is ready')
+              deferred.resolve()
+              // continue finding peers until we reach this.maxProviders
+            }
+
+            if (this.providers.length === this.maxProviders) {
+              this.log('found max session peers', found)
+              break
+            }
           }
+        }
+
+        // still not got enough providers, search routing for more
+        if (found < this.maxProviders) {
+          for await (const provider of this.findNewProviders(cid, options)) {
+            if (found === this.maxProviders || options.signal?.aborted === true) {
+              break
+            }
+
+            if (this.hasProvider(provider)) {
+              continue
+            }
+
+            this.log('found %d/%d new providers', found, this.maxProviders)
+            this.providers.push(provider)
+
+            // let the new peer join current queries
+            this.safeDispatchEvent('provider', {
+              detail: provider
+            })
 
-          if (this.providers.length === this.maxProviders) {
-            this.log('found max session peers', found)
-            break
+            found++
+
+            if (found === count) {
+              this.log('session is ready')
+              deferred.resolve()
+              // continue finding peers until we reach this.maxProviders
+            }
+
+            if (this.providers.length === this.maxProviders) {
+              this.log('found max session peers', found)
+              break
+            }
           }
         }
 
@@ -261,6 +322,13 @@ export abstract class AbstractSession<Provider, RetrieveBlockProgressEvents exte
     return deferred.promise
   }
 
+  /**
+   * If this session was created with specific providers, convert one of them
+   * into the format required or return `undefined` if the provider is not
+   * compatible with this session implementation
+   */
+  abstract convertToProvider (provider: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions): Promise<Provider | undefined>
+
   /**
    * This method should search for new providers and yield them.
    */

package/src/pins.ts

@@ -1,16 +1,19 @@
 import { Queue } from '@libp2p/utils/queue'
 import * as cborg from 'cborg'
-import { type Datastore, Key } from 'interface-datastore'
+import { Key } from 'interface-datastore'
 import { base36 } from 'multiformats/bases/base36'
 import { createUnsafe } from 'multiformats/block'
-import { CID, type Version } from 'multiformats/cid'
-import { CustomProgressEvent, type ProgressOptions } from 'progress-events'
+import { CID } from 'multiformats/cid'
+import { CustomProgressEvent } from 'progress-events'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import type { CodecLoader } from '@helia/interface'
 import type { GetBlockProgressEvents } from '@helia/interface/blocks'
 import type { AddOptions, AddPinEvents, IsPinnedOptions, LsOptions, Pin, Pins, RmOptions } from '@helia/interface/pins'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
+import type { Datastore } from 'interface-datastore'
+import type { Version } from 'multiformats/cid'
+import type { ProgressOptions } from 'progress-events'
 
 interface DatastorePin {
   /**

package/src/utils/datastore-version.ts

@@ -1,6 +1,7 @@
-import { type Datastore, Key } from 'interface-datastore'
+import { Key } from 'interface-datastore'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import type { Datastore } from 'interface-datastore'
 
 const DS_VERSION_KEY = new Key('/version')
 const CURRENT_VERSION = 1

package/src/utils/networked-storage.ts

@@ -3,7 +3,7 @@ import { anySignal } from 'any-signal'
 import { IdentityBlockstore } from 'blockstore-core/identity'
 import filter from 'it-filter'
 import forEach from 'it-foreach'
-import { CustomProgressEvent, type ProgressOptions } from 'progress-events'
+import { CustomProgressEvent } from 'progress-events'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { isPromise } from './is-promise.js'
 import type { HasherLoader } from '@helia/interface'
@@ -13,6 +13,7 @@ import type { Blockstore } from 'interface-blockstore'
 import type { AwaitIterable } from 'interface-store'
 import type { CID } from 'multiformats/cid'
 import type { MultihashDigest, MultihashHasher } from 'multiformats/hashes/interface'
+import type { ProgressOptions } from 'progress-events'
 
 export interface GetOptions extends AbortOptions {
   progress?(evt: Event): void

package/dist/typedoc-urls.json

@@ -1,12 +0,0 @@
-{
-  "AbstractSession": "https://ipfs.github.io/helia/classes/_helia_utils.AbstractSession.html",
-  "BlockStorage": "https://ipfs.github.io/helia/classes/_helia_utils.BlockStorage.html",
-  "Helia": "https://ipfs.github.io/helia/classes/_helia_utils.Helia.html",
-  ".:Helia": "https://ipfs.github.io/helia/classes/_helia_utils.Helia.html",
-  "AbstractCreateSessionOptions": "https://ipfs.github.io/helia/interfaces/_helia_utils.AbstractCreateSessionOptions.html",
-  "AbstractSessionComponents": "https://ipfs.github.io/helia/interfaces/_helia_utils.AbstractSessionComponents.html",
-  "BlockStorageInit": "https://ipfs.github.io/helia/interfaces/_helia_utils.BlockStorageInit.html",
-  "BlockstoreSessionEvents": "https://ipfs.github.io/helia/interfaces/_helia_utils.BlockstoreSessionEvents.html",
-  "HeliaInit": "https://ipfs.github.io/helia/interfaces/_helia_utils.HeliaInit.html",
-  ".:HeliaInit": "https://ipfs.github.io/helia/interfaces/_helia_utils.HeliaInit.html"
-}