@xyo-network/bridge-pub-sub 2.92.10 → 2.93.0-rc.1

package/src/PubSubBridge.ts

@@ -1,8 +1,9 @@
 import { assertEx } from '@xylabs/assert'
+import { exists } from '@xylabs/exists'
 import { Address } from '@xylabs/hex'
 import { AbstractBridge } from '@xyo-network/abstract-bridge'
 import { BridgeExposeOptions, BridgeModule, BridgeUnexposeOptions } from '@xyo-network/bridge-model'
-import { creatableModule, ModuleFilterOptions, ModuleIdentifier } from '@xyo-network/module-model'
+import { creatableModule, ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '@xyo-network/module-model'
 import { LRUCache } from 'lru-cache'
 
 import { AsyncQueryBusClient, AsyncQueryBusHost } from './AsyncQueryBus'
@@ -32,8 +33,6 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
       new PubSubBridgeModuleResolver({
         bridge: this,
         busClient: assertEx(this.busClient(), () => 'busClient not configured'),
-        downResolver: this.downResolver,
-        upResolver: this.upResolver,
         wrapperAccount: this.account,
       })
     return this._resolver
@@ -43,24 +42,43 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
     return `${this.config.name ?? moduleName}`
   }
 
-  async exposeHandler(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<Address[]> {
-    const filterOptions: ModuleFilterOptions = { direction: options?.direction }
+  protected get roots() {
+    return assertEx(this.config.roots, () => 'roots not configured')
+  }
+
+  async exposeHandler(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
+    const { maxDepth = 1, direction } = options ?? {}
+    const filterOptions: ModuleFilterOptions = { direction }
     const module = await super.resolve(id, filterOptions)
     if (module) {
       const host = assertEx(this.busHost(), () => 'Not configured as a host')
       host.expose(module.address)
-      return [module.address]
+      const children = await module.resolve('*', { direction, maxDepth, visibility: 'public' })
+      for (const child of children) {
+        host.expose(child.address)
+      }
+      return [module, ...children]
     }
     return []
   }
 
-  async unexposeHandler(id: ModuleIdentifier, options?: BridgeUnexposeOptions | undefined): Promise<Address[]> {
-    const filterOptions: ModuleFilterOptions = { direction: options?.direction }
+  override async startHandler(): Promise<boolean> {
+    this.busHost()?.start()
+    return await super.startHandler()
+  }
+
+  async unexposeHandler(id: ModuleIdentifier, options?: BridgeUnexposeOptions | undefined): Promise<ModuleInstance[]> {
+    const { maxDepth = 1, direction } = options ?? {}
+    const filterOptions: ModuleFilterOptions = { direction }
     const module = await super.resolve(id, filterOptions)
     if (module) {
       const host = assertEx(this.busHost(), () => 'Not configured as a host')
       host.unexpose(module.address)
-      return [module.address]
+      const children = await module.resolve('*', { direction, maxDepth, visibility: 'public' })
+      for (const child of children) {
+        host.unexpose(child.address)
+      }
+      return [module, ...children]
     }
     return []
   }
@@ -70,7 +88,7 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
       this._busClient = new AsyncQueryBusClient({
         config: this.config.client,
         logger: this.logger,
-        resolver: this,
+        resolver: this.upResolver,
       })
     }
     return this._busClient
@@ -81,15 +99,18 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
       this._busHost = new AsyncQueryBusHost({
         config: this.config.host,
         logger: this.logger,
-        resolver: this,
+        resolver: this.upResolver,
       })
     }
     return this._busHost
   }
 
-  protected override startHandler(): Promise<boolean> {
-    this.busHost()?.start()
-    return Promise.resolve(true)
+  protected override async discoverRoots(): Promise<ModuleInstance[]> {
+    const rootInstances = (await Promise.all(this.roots.map(async (root) => await this.resolver.resolve<ModuleInstance>(root)))).filter(exists)
+    for (const instance of rootInstances) {
+      this.downResolver.add(instance)
+    }
+    return rootInstances
   }
 
   protected override stopHandler(_timeout?: number | undefined) {

package/src/PubSubBridgeModuleResolver.ts

@@ -1,5 +1,6 @@
-import { Address } from '@xylabs/hex'
-import { AbstractBridgeModuleResolver, BridgeModuleResolverOptions } from '@xyo-network/abstract-bridge'
+import { assertEx } from '@xylabs/assert'
+import { Address, isAddress } from '@xylabs/hex'
+import { AbstractBridgeModuleResolver, BridgeModuleResolverOptions, wrapModuleWithType } from '@xyo-network/abstract-bridge'
 import { Account } from '@xyo-network/account'
 import { ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '@xyo-network/module-model'
 
@@ -9,12 +10,18 @@ export interface PubSubBridgeModuleResolverOptions extends BridgeModuleResolverO
   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> {
+export class PubSubBridgeModuleResolver extends AbstractBridgeModuleResolver<PubSubBridgeModuleResolverOptions> {
+  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(
+    id: ModuleIdentifier,
+    options?: ModuleFilterOptions<T>,
+  ): Promise<T | T[] | undefined> {
+    const parentResult = await super.resolveHandler(id, options)
+    if (parentResult) {
+      return parentResult
+    }
     const idParts = id.split(':')
     const firstPart = idParts.shift()
+    assertEx(isAddress(firstPart), () => `Invalid module address: ${firstPart}`)
     const remainderParts = idParts.join(':')
     const account = Account.randomSync()
     const params: AsyncQueryBusModuleProxyParams = {
@@ -24,6 +31,10 @@ export class PubSubBridgeModuleResolver<
       moduleAddress: firstPart as Address,
     }
     const proxy = new AsyncQueryBusModuleProxy<T>(params) as unknown as T
-    return remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : proxy
+    await proxy.start?.()
+    const wrappedProxy = wrapModuleWithType(proxy, account) as unknown as T
+    this.add(wrappedProxy)
+    console.log('ding!')
+    return remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : wrappedProxy
   }
 }