@xyo-network/bridge-pub-sub 2.92.7 → 2.92.9

package/src/PubSubBridge.ts

@@ -1,22 +1,19 @@
 import { assertEx } from '@xylabs/assert'
 import { Address } from '@xylabs/hex'
 import { AbstractBridge } from '@xyo-network/abstract-bridge'
-import { Account } from '@xyo-network/account'
 import { BridgeExposeOptions, BridgeModule, BridgeUnexposeOptions } from '@xyo-network/bridge-model'
-import { creatableModule, ModuleEventData, ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '@xyo-network/module-model'
+import { creatableModule, ModuleFilterOptions, ModuleIdentifier } from '@xyo-network/module-model'
 import { LRUCache } from 'lru-cache'
 
-import { AsyncQueryBusClient, AsyncQueryBusHost, AsyncQueryBusModuleProxy, AsyncQueryBusModuleProxyParams } from './AsyncQueryBus'
+import { AsyncQueryBusClient, AsyncQueryBusHost } from './AsyncQueryBus'
 import { PubSubBridgeConfigSchema } from './Config'
 import { PubSubBridgeParams } from './Params'
+import { PubSubBridgeModuleResolver } from './PubSubBridgeModuleResolver'
 
 const moduleName = 'PubSubBridge'
 
 @creatableModule()
-export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends AbstractBridge<TParams, TEventData>
-  implements BridgeModule<TParams, TEventData>
-{
+export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParams> extends AbstractBridge<TParams> implements BridgeModule<TParams> {
   static override configSchemas = [PubSubBridgeConfigSchema]
 
   protected _configRootAddress: Address = ''
@@ -27,42 +24,41 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
 
   private _busClient?: AsyncQueryBusClient
   private _busHost?: AsyncQueryBusHost
+  private _resolver?: PubSubBridgeModuleResolver
+
+  override get resolver() {
+    this._resolver =
+      this._resolver ??
+      new PubSubBridgeModuleResolver({
+        bridge: this,
+        busClient: assertEx(this.busClient(), () => 'busClient not configured'),
+        downResolver: this.downResolver,
+        upResolver: this.upResolver,
+        wrapperAccount: this.account,
+      })
+    return this._resolver
+  }
 
   protected get moduleName() {
     return `${this.config.name ?? moduleName}`
   }
 
-  async exposeHandler(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<Lowercase<string>[]> {
+  async exposeHandler(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<Address[]> {
     const filterOptions: ModuleFilterOptions = { direction: options?.direction }
     const module = await super.resolve(id, filterOptions)
     if (module) {
-      const host = assertEx(this.busHost(), 'Not configured as a host')
+      const host = assertEx(this.busHost(), () => 'Not configured as a host')
       host.expose(module.address)
       return [module.address]
     }
     return []
   }
 
-  async resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined> {
-    const idParts = id.split(':')
-    const firstPart = idParts.shift()
-    const remainderParts = idParts.join(':')
-    const account = Account.randomSync()
-    const params: AsyncQueryBusModuleProxyParams = {
-      account,
-      bridge: this,
-      busClient: assertEx(this.busClient(), 'Bus client not initialized'),
-      moduleAddress: firstPart as Address,
-    }
-    const proxy = new AsyncQueryBusModuleProxy<T>(params) as unknown as T
-    return remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : proxy
-  }
-
-  async unexposeHandler(id: ModuleIdentifier, options?: BridgeUnexposeOptions | undefined): Promise<Lowercase<string>[]> {
+  async unexposeHandler(id: ModuleIdentifier, options?: BridgeUnexposeOptions | undefined): Promise<Address[]> {
     const filterOptions: ModuleFilterOptions = { direction: options?.direction }
     const module = await super.resolve(id, filterOptions)
     if (module) {
-      const host = assertEx(this.busHost(), 'Not configured as a host')
+      const host = assertEx(this.busHost(), () => 'Not configured as a host')
       host.unexpose(module.address)
       return [module.address]
     }

package/src/PubSubBridgeModuleResolver.ts

@@ -0,0 +1,29 @@
+import { Address } from '@xylabs/hex'
+import { AbstractBridgeModuleResolver, BridgeModuleResolverOptions } from '@xyo-network/abstract-bridge'
+import { Account } from '@xyo-network/account'
+import { ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '@xyo-network/module-model'
+
+import { AsyncQueryBusClient, AsyncQueryBusModuleProxy, AsyncQueryBusModuleProxyParams } from './AsyncQueryBus'
+
+export interface PubSubBridgeModuleResolverOptions extends BridgeModuleResolverOptions {
+  busClient: AsyncQueryBusClient
+}
+
+export class PubSubBridgeModuleResolver<
+  T extends PubSubBridgeModuleResolverOptions = PubSubBridgeModuleResolverOptions,
+> extends AbstractBridgeModuleResolver<T> {
+  async resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined> {
+    const idParts = id.split(':')
+    const firstPart = idParts.shift()
+    const remainderParts = idParts.join(':')
+    const account = Account.randomSync()
+    const params: AsyncQueryBusModuleProxyParams = {
+      account,
+      busClient: this.options.busClient,
+      host: this.options.bridge,
+      moduleAddress: firstPart as Address,
+    }
+    const proxy = new AsyncQueryBusModuleProxy<T>(params) as unknown as T
+    return remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : proxy
+  }
+}

package/src/index.ts

@@ -3,4 +3,5 @@ export * from './AsyncQueryBus'
 export * from './Config'
 export * from './Params'
 export * from './PubSubBridge'
+export * from './PubSubBridgeModuleResolver'
 export * from './Schema'