@xyo-network/bridge-pub-sub 2.94.7 → 2.94.9

package/src/AsyncQueryBus/AsyncQueryBusBase.ts

@@ -1,7 +1,7 @@
 import { assertEx } from '@xylabs/assert'
 import { Address } from '@xylabs/hex'
 import { Base, toJsonString } from '@xylabs/object'
-import { asArchivistInstance } from '@xyo-network/archivist-model'
+import { ArchivistInstance, asArchivistInstance } from '@xyo-network/archivist-model'
 import { BoundWitness, QueryBoundWitness } from '@xyo-network/boundwitness-model'
 import { BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload } from '@xyo-network/diviner-boundwitness-model'
 import { asDivinerInstance, DivinerInstance } from '@xyo-network/diviner-model'
@@ -15,6 +15,16 @@ export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryB
   protected _targetConfigs: Record<Address, ModuleConfig> = {}
   protected _targetQueries: Record<Address, string[]> = {}
 
+  private _lastQueriesArchivistAttempt?: number
+  private _lastQueriesDivinerAttempt?: number
+  private _lastResponseArchivistAttempt?: number
+  private _lastResponseDivinerAttempt?: number
+  private _queriesArchivist?: ArchivistInstance
+  private _queriesDiviner?: DivinerInstance<BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload, QueryBoundWitness>
+  private _reResolveDelay = 5000
+  private _responseArchivist?: ArchivistInstance
+  private _responseDiviner?: DivinerInstance<BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload, BoundWitness>
+
   constructor(params: TParams) {
     super(params)
   }
@@ -41,6 +51,12 @@ export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryB
   }
 
   async queriesArchivist() {
+    if (this._queriesArchivist) {
+      return this._queriesArchivist
+    }
+    if (this._lastQueriesArchivistAttempt && Date.now() - this._lastQueriesArchivistAttempt < this._reResolveDelay) {
+      return
+    }
     const resolved = await this.resolver.resolve(this.config?.intersect?.queries?.archivist, { direction: 'up' })
     const existingResolved = assertEx(resolved, () => `Unable to resolve queriesArchivist [${this.config?.intersect?.queries?.archivist}]`)
     const result = asArchivistInstance(
@@ -48,28 +64,52 @@ export class AsyncQueryBusBase<TParams extends AsyncQueryBusParams = AsyncQueryB
       () =>
         `Unable to resolve queriesArchivist as correct type [${this.config?.intersect?.queries?.archivist}][${existingResolved?.constructor?.name}]: ${toJsonString(existingResolved)}`,
     )
+    this._queriesArchivist = result
     return result
   }
 
   async queriesDiviner() {
-    return assertEx(
+    if (this._queriesDiviner) {
+      return this._queriesDiviner
+    }
+    if (this._lastQueriesDivinerAttempt && Date.now() - this._lastQueriesDivinerAttempt < this._reResolveDelay) {
+      return
+    }
+    this._queriesDiviner = assertEx(
       asDivinerInstance(await this.resolver.resolve(this.config?.intersect?.queries?.boundWitnessDiviner)),
       () => `Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`,
     ) as DivinerInstance<BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload, QueryBoundWitness>
+
+    return this._queriesDiviner
   }
 
   async responsesArchivist() {
-    return assertEx(
+    if (this._responseArchivist) {
+      return this._responseArchivist
+    }
+    if (this._lastResponseArchivistAttempt && Date.now() - this._lastResponseArchivistAttempt < this._reResolveDelay) {
+      return
+    }
+    this._responseArchivist = assertEx(
       asArchivistInstance(await this.resolver.resolve(this.config?.intersect?.responses?.archivist)),
       () => `Unable to resolve responsesArchivist [${this.config?.intersect?.responses?.archivist}]`,
     )
+    return this._responseArchivist
   }
 
   async responsesDiviner() {
-    return assertEx(
+    if (this._responseDiviner) {
+      return this._responseDiviner
+    }
+    if (this._lastResponseDivinerAttempt && Date.now() - this._lastResponseDivinerAttempt < this._reResolveDelay) {
+      return
+    }
+    this._responseDiviner = assertEx(
       asDivinerInstance(await this.resolver.resolve(this.config?.intersect?.responses?.boundWitnessDiviner)),
       () => `Unable to resolve responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`,
     ) as DivinerInstance<BoundWitnessDivinerParams, BoundWitnessDivinerQueryPayload, BoundWitness>
+
+    return this._responseDiviner
   }
 
   /**

package/src/AsyncQueryBus/AsyncQueryBusClient.ts

@@ -1,3 +1,4 @@
+import { assertEx } from '@xylabs/assert'
 import { delay } from '@xylabs/delay'
 import { forget } from '@xylabs/forget'
 import { Address } from '@xylabs/hex'
@@ -50,7 +51,10 @@ export class AsyncQueryBusClient<TParams extends AsyncQueryBusClientParams = Asy
     const $meta = { ...query?.$meta, destination: [address] }
     const routedQuery = await PayloadBuilder.build({ ...query, $meta })
     //console.log('queryArchivist - calling')
-    const queryArchivist = await this.queriesArchivist()
+    const queryArchivist = assertEx(
+      await this.queriesArchivist(),
+      () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`,
+    )
     //console.log('queryArchivist')
 
     // TODO: Should we always re-hash to true up timestamps?  We can't
@@ -134,8 +138,14 @@ export class AsyncQueryBusClient<TParams extends AsyncQueryBusClientParams = Asy
    * Background process for processing incoming responses to previously issued queries
    */
   private processIncomingResponses = async () => {
-    const responseArchivist = await this.responsesArchivist()
-    const responseBoundWitnessDiviner = await this.responsesDiviner()
+    const responseArchivist = assertEx(
+      await this.responsesArchivist(),
+      () => `Unable to contact the responsesArchivist [${this.config?.intersect?.responses?.archivist}]`,
+    )
+    const responseBoundWitnessDiviner = assertEx(
+      await this.responsesDiviner(),
+      () => `Unable to contact responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`,
+    )
     const pendingCommands = [...this.queryCache.entries()].filter(([_, status]) => status === Pending)
     // TODO: Do in throttled batches
     await Promise.allSettled(

package/src/AsyncQueryBus/AsyncQueryBusHost.ts

@@ -79,8 +79,14 @@ export class AsyncQueryBusHost<TParams extends AsyncQueryBusHostParams = AsyncQu
 
   protected callLocalModule = async (localModule: ModuleInstance, query: WithMeta<QueryBoundWitness>) => {
     const localModuleName = localModule.config.name ?? localModule.address
-    const queryArchivist = await this.queriesArchivist()
-    const responseArchivist = await this.responsesArchivist()
+    const queryArchivist = assertEx(
+      await this.queriesArchivist(),
+      () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`,
+    )
+    const responsesArchivist = assertEx(
+      await this.responsesArchivist(),
+      () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`,
+    )
     const queryDestination = (query.$meta as { destination?: string[] })?.destination
     if (queryDestination && queryDestination?.includes(localModule.address)) {
       // Find the query
@@ -108,7 +114,7 @@ export class AsyncQueryBusHost<TParams extends AsyncQueryBusHostParams = AsyncQu
             })
             const [bw, payloads, errors] = response
             this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`)
-            const insertResult = await responseArchivist.insert([bw, ...payloads, ...errors])
+            const insertResult = await responsesArchivist.insert([bw, ...payloads, ...errors])
             // NOTE: If all archivists support the contract that numPayloads inserted === numPayloads returned we can
             // do some deeper assertions here like lenIn === lenOut, but for now this should be good enough since BWs
             // should always be unique causing at least one insertion
@@ -135,7 +141,10 @@ export class AsyncQueryBusHost<TParams extends AsyncQueryBusHostParams = AsyncQu
    * @param address The address to find commands for
    */
   protected findQueriesToAddress = async (address: Address) => {
-    const queryBoundWitnessDiviner = await this.queriesDiviner()
+    const queryBoundWitnessDiviner = assertEx(
+      await this.queriesDiviner(),
+      () => `Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`,
+    )
     // Retrieve last offset from state store
     const timestamp = await this.retrieveState(address)
     const destination = [address]