@xyo-network/bridge-pub-sub 2.92.11 → 2.93.0-rc.2

package/src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts

@@ -1,6 +1,6 @@
 import { AbstractModuleProxy, ModuleProxyParams } from '@xyo-network/abstract-bridge'
 import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
-import { Module, ModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
+import { ModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
 import { Payload } from '@xyo-network/payload-model'
 
 import { AsyncQueryBusClient } from '../AsyncQueryBusClient'
@@ -9,11 +9,24 @@ export type AsyncQueryBusModuleProxyParams = ModuleProxyParams & {
   busClient: AsyncQueryBusClient
 }
 
-export class AsyncQueryBusModuleProxy<TWrappedModule extends Module = Module>
-  extends AbstractModuleProxy<AsyncQueryBusModuleProxyParams, TWrappedModule>
-  implements ModuleInstance<TWrappedModule['params'], TWrappedModule['eventData']>
+export class AsyncQueryBusModuleProxy<
+    TWrappedModule extends ModuleInstance = ModuleInstance,
+    TParams extends Omit<AsyncQueryBusModuleProxyParams, 'config'> & { config: TWrappedModule['config'] } = Omit<
+      AsyncQueryBusModuleProxyParams,
+      'config'
+    > & {
+      config: TWrappedModule['config']
+    },
+  >
+  extends AbstractModuleProxy<TWrappedModule, TParams>
+  implements ModuleInstance<TParams, TWrappedModule['eventData']>
 {
+  pipeline?: 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many' | undefined
   async proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads?: Payload[]): Promise<ModuleQueryResult> {
-    return await this.proxyParams.busClient.send(this.address, query, payloads)
+    return await this.params.busClient.send(this.address, query, payloads)
+  }
+
+  override async startHandler(): Promise<boolean> {
+    return await super.startHandler()
   }
 }

package/src/Config.ts

@@ -1,3 +1,4 @@
+import { Address } from '@xylabs/hex'
 import { EmptyObject } from '@xylabs/object'
 import { BridgeConfig } from '@xyo-network/bridge-model'
 
@@ -14,6 +15,7 @@ export type PubSubBridgeConfig<TConfig extends EmptyObject = EmptyObject, TSchem
   {
     client?: AsyncQueryBusClientConfig
     host?: AsyncQueryBusHostConfig
+    roots?: Address[]
   } & TConfig,
   TSchema extends string ? TSchema : PubSubBridgeConfigSchema
 >

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, ModuleResolverInstance } from '@xyo-network/module-model'
 import { LRUCache } from 'lru-cache'
 
 import { AsyncQueryBusClient, AsyncQueryBusHost } from './AsyncQueryBus'
@@ -26,14 +27,12 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
   private _busHost?: AsyncQueryBusHost
   private _resolver?: PubSubBridgeModuleResolver
 
-  override get resolver() {
+  override get resolver(): ModuleResolverInstance {
     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
@@ -43,24 +42,56 @@ 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 }
-    const module = await super.resolve(id, filterOptions)
+  protected get roots() {
+    return assertEx(this.config.roots, () => 'roots not configured')
+  }
+
+  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
+  }
+
+  async exposeHandler(id: ModuleIdentifier, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
+    const { maxDepth = 5, direction } = options ?? {}
+    const filterOptions: ModuleFilterOptions = { direction }
+    const module = assertEx(await super.resolve(id, filterOptions), () => `Expose failed to locate module [${id}]`)
     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 }
+  exposedHandler(): Address[] {
+    const exposedSet = this.busHost()?.exposedAddresses
+    return exposedSet ? [...exposedSet] : []
+  }
+
+  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 []
   }
@@ -87,11 +118,6 @@ export class PubSubBridge<TParams extends PubSubBridgeParams = PubSubBridgeParam
     return this._busHost
   }
 
-  protected override startHandler(): Promise<boolean> {
-    this.busHost()?.start()
-    return Promise.resolve(true)
-  }
-
   protected override stopHandler(_timeout?: number | undefined) {
     this.busHost()?.stop()
     return true

package/src/PubSubBridgeModuleResolver.ts

@@ -1,7 +1,9 @@
-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'
+import { ConfigPayload, ConfigSchema } from '@xyo-network/config-payload-plugin'
+import { ModuleConfig, ModuleConfigSchema, ModuleFilterOptions, ModuleIdentifier, ModuleInstance } from '@xyo-network/module-model'
 
 import { AsyncQueryBusClient, AsyncQueryBusModuleProxy, AsyncQueryBusModuleProxyParams } from './AsyncQueryBus'
 
@@ -9,21 +11,42 @@ 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 = {
       account,
       busClient: this.options.busClient,
+      config: { schema: ModuleConfigSchema },
       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
+    const proxy = new AsyncQueryBusModuleProxy<T, AsyncQueryBusModuleProxyParams>(params)
+    if (proxy) {
+      const state = await proxy.state()
+      if (state) {
+        const configSchema = (state.find((payload) => payload.schema === ConfigSchema) as ConfigPayload | undefined)?.config
+        const config = assertEx(
+          state.find((payload) => payload.schema === configSchema),
+          () => 'Unable to locate config',
+        ) as ModuleConfig
+        proxy.setConfig(config)
+      }
+    }
+    await proxy.start?.()
+    const wrappedProxy = wrapModuleWithType(proxy, account) as unknown as T
+    this.add(wrappedProxy)
+    return remainderParts.length > 0 ? await proxy.resolve(remainderParts, options) : wrappedProxy
   }
 }