@xyo-network/bridge-pub-sub 2.101.8 → 2.101.9

package/src/PubSubBridgeModuleResolver.ts

@@ -4,6 +4,7 @@ import { AbstractBridgeModuleResolver, BridgeModuleResolverParams, wrapModuleWit
 import { Account } from '@xyo-network/account'
 import { ConfigPayload, ConfigSchema } from '@xyo-network/config-payload-plugin'
 import { asModuleInstance, ModuleConfig, ModuleConfigSchema, ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '@xyo-network/module-model'
+import { Mutex } from 'async-mutex'
 import { LRUCache } from 'lru-cache'
 
 import { AsyncQueryBusClient, AsyncQueryBusModuleProxy, AsyncQueryBusModuleProxyParams } from './AsyncQueryBus'
@@ -14,6 +15,7 @@ export interface PubSubBridgeModuleResolverParams extends BridgeModuleResolverPa
 
 export class PubSubBridgeModuleResolver extends AbstractBridgeModuleResolver<PubSubBridgeModuleResolverParams> {
   protected _resolvedCache = new LRUCache<Address, ModuleInstance>({ max: 1000 })
+  protected _resolvedCacheMutex = new Mutex()
 
   override async resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T[]> {
     const parentResult = await super.resolveHandler(id, options)
@@ -24,24 +26,24 @@ export class PubSubBridgeModuleResolver extends AbstractBridgeModuleResolver<Pub
     const firstPart = idParts.shift()
     assertEx(isAddress(firstPart), () => `Invalid module address: ${firstPart}`)
     const remainderParts = idParts.join(':')
-    const cachedMod = this._resolvedCache.get(firstPart as Address)
-    if (cachedMod) {
-      const result = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, { ...options, maxDepth: (options?.maxDepth ?? 5) - 1 })
-      return (result ? [result] : []) as T[]
-    }
-    const account = Account.randomSync()
-    const finalParams: AsyncQueryBusModuleProxyParams = {
-      account,
-      archiving: this.params.archiving,
-      busClient: this.params.busClient,
-      config: { schema: ModuleConfigSchema },
-      host: this,
-      moduleAddress: firstPart as Address,
-      onQuerySendFinished: this.params.onQuerySendFinished,
-      onQuerySendStarted: this.params.onQuerySendStarted,
-    }
-    const proxy = new AsyncQueryBusModuleProxy<T, AsyncQueryBusModuleProxyParams>(finalParams)
-    if (proxy) {
+    const instance: T = await this._resolvedCacheMutex.runExclusive(async () => {
+      const cachedMod = this._resolvedCache.get(firstPart as Address)
+      if (cachedMod) {
+        const result = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, { ...options, maxDepth: (options?.maxDepth ?? 5) - 1 })
+        return result as T
+      }
+      const account = Account.randomSync()
+      const finalParams: AsyncQueryBusModuleProxyParams = {
+        account,
+        archiving: this.params.archiving,
+        busClient: this.params.busClient,
+        config: { schema: ModuleConfigSchema },
+        host: this,
+        moduleAddress: firstPart as Address,
+        onQuerySendFinished: this.params.onQuerySendFinished,
+        onQuerySendStarted: this.params.onQuerySendStarted,
+      }
+      const proxy = new AsyncQueryBusModuleProxy<T, AsyncQueryBusModuleProxyParams>(finalParams)
       const state = await proxy.state()
       if (state) {
         const configSchema = (state.find((payload) => payload.schema === ConfigSchema) as ConfigPayload | undefined)?.config
@@ -51,14 +53,13 @@ export class PubSubBridgeModuleResolver extends AbstractBridgeModuleResolver<Pub
         ) as ModuleConfig
         proxy.setConfig(config)
       }
-    }
-    await proxy.start?.()
-    const wrapped = wrapModuleWithType(proxy, account) as unknown as T
-    const instance = assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
-    //proxy.upResolver.add(instance)
-    //proxy.downResolver.add(instance)
-    this._resolvedCache.set(instance.address, instance)
-    const result = remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : instance
+      await proxy.start?.()
+      const wrapped = wrapModuleWithType(proxy, account) as unknown as T
+      assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
+      this._resolvedCache.set(proxy.address, proxy)
+      return proxy as ModuleInstance as T
+    })
+    const result = remainderParts.length > 0 ? await instance.resolve(remainderParts, options) : instance
     return result ? [result] : []
   }
 }