@xyo-network/bridge 2.46.4 → 2.47.0

package/package.json

@@ -11,16 +11,16 @@
   },
   "dependencies": {
     "@xylabs/assert": "^2.7.1",
-    "@xyo-network/account": "^2.46.4",
-    "@xyo-network/address-payload-plugin": "^2.46.4",
-    "@xyo-network/api-models": "^2.46.4",
-    "@xyo-network/axios": "^2.46.4",
-    "@xyo-network/module": "^2.46.4",
-    "@xyo-network/module-model": "^2.46.4",
-    "@xyo-network/payload-model": "^2.46.4",
-    "@xyo-network/payload-wrapper": "^2.46.4",
-    "@xyo-network/promise": "^2.46.4",
-    "@xyo-network/query-payload-plugin": "^2.46.4",
+    "@xyo-network/account": "^2.47.0",
+    "@xyo-network/address-payload-plugin": "^2.47.0",
+    "@xyo-network/api-models": "^2.47.0",
+    "@xyo-network/axios": "^2.47.0",
+    "@xyo-network/module": "^2.47.0",
+    "@xyo-network/module-model": "^2.47.0",
+    "@xyo-network/payload-model": "^2.47.0",
+    "@xyo-network/payload-wrapper": "^2.47.0",
+    "@xyo-network/promise": "^2.47.0",
+    "@xyo-network/query-payload-plugin": "^2.47.0",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
@@ -61,5 +61,5 @@
   },
   "sideEffects": false,
   "types": "dist/types/index.d.ts",
-  "version": "2.46.4"
+  "version": "2.47.0"
 }

package/src/AbstractBridge.ts

@@ -1,5 +1,16 @@
 import { Account } from '@xyo-network/account'
-import { AbstractModule, ModuleQueryResult, QueryBoundWitnessWrapper, XyoErrorBuilder, XyoQuery, XyoQueryBoundWitness } from '@xyo-network/module'
+import {
+  AbstractModule,
+  Module,
+  ModuleConfig,
+  ModuleFilter,
+  ModuleQueryResult,
+  ModuleResolver,
+  QueryBoundWitnessWrapper,
+  XyoErrorBuilder,
+  XyoQuery,
+  XyoQueryBoundWitness,
+} from '@xyo-network/module'
 import { XyoPayload } from '@xyo-network/payload-model'
 import { Promisable } from '@xyo-network/promise'
 
@@ -8,6 +19,8 @@ import { BridgeConfig } from './Config'
 import { XyoBridgeConnectQuerySchema, XyoBridgeDisconnectQuerySchema, XyoBridgeQuery } from './Queries'
 
 export abstract class AbstractBridge<TConfig extends BridgeConfig = BridgeConfig> extends AbstractModule<TConfig> implements BridgeModule {
+  abstract targetResolver: ModuleResolver
+
   override get queries(): string[] {
     return [XyoBridgeConnectQuerySchema, XyoBridgeDisconnectQuerySchema, ...super.queries]
   }
@@ -27,11 +40,7 @@ export abstract class AbstractBridge<TConfig extends BridgeConfig = BridgeConfig
           break
         }
         default:
-          if (super.queries.includes(typedQuery.schema)) {
-            return super.query(query, payloads)
-          } else {
-            return this.forward(typedQuery)
-          }
+          return super.query(query, payloads)
       }
     } catch (ex) {
       const error = ex as Error
@@ -43,5 +52,11 @@ export abstract class AbstractBridge<TConfig extends BridgeConfig = BridgeConfig
   abstract connect(): Promisable<boolean>
   abstract disconnect(): Promisable<boolean>
 
-  abstract forward(query: XyoQuery): Promise<ModuleQueryResult>
+  abstract targetConfig(address: string): Promisable<ModuleConfig>
+
+  abstract targetQuery(address: string, query: XyoQuery, payloads?: XyoPayload[]): Promisable<ModuleQueryResult>
+
+  abstract targetQueryable(address: string, query: XyoQueryBoundWitness, payloads?: XyoPayload[], queryConfig?: ModuleConfig): boolean
+
+  abstract targetResolve(address: string, filter?: ModuleFilter): Promisable<Module[]>
 }

package/src/Bridge.ts

@@ -1,9 +1,17 @@
-import { Module } from '@xyo-network/module-model'
+import { Module, ModuleConfig, ModuleFilter, ModuleQueryResult, XyoQuery, XyoQueryBoundWitness } from '@xyo-network/module-model'
+import { XyoPayload } from '@xyo-network/payload-model'
 import { Promisable } from '@xyo-network/promise'
 
+import { BridgeConfig } from './Config'
+
 export interface Bridge {
   connect: () => Promisable<boolean>
   disconnect: () => Promisable<boolean>
 }
 
-export interface BridgeModule extends Bridge, Module {}
+export interface BridgeModule<TConfig extends BridgeConfig = BridgeConfig> extends Bridge, Module<TConfig> {
+  targetResolver: Module['resolver']
+  targetQuery(address: string, query: XyoQuery, payloads?: XyoPayload[]): Promisable<ModuleQueryResult>
+  targetQueryable(address: string, query: XyoQueryBoundWitness, payloads?: XyoPayload[], queryConfig?: ModuleConfig): Promisable<boolean>
+  targetResolve(address: string, filter?: ModuleFilter): Promisable<Module[]>
+}

package/src/BridgeWrapper.ts

@@ -1,10 +1,24 @@
-import { ModuleWrapper } from '@xyo-network/module'
+import {
+  ModuleConfig,
+  ModuleDiscoverQuery,
+  ModuleDiscoverQuerySchema,
+  ModuleFilter,
+  ModuleQueryResult,
+  ModuleWrapper,
+  XyoQuery,
+  XyoQueryBoundWitness,
+} from '@xyo-network/module'
+import { XyoPayload, XyoPayloads } from '@xyo-network/payload-model'
 import { PayloadWrapper } from '@xyo-network/payload-wrapper'
 
-import { Bridge } from './Bridge'
+import { BridgeModule } from './Bridge'
 import { XyoBridgeConnectQuerySchema, XyoBridgeDisconnectQuerySchema, XyoBridgeQuery } from './Queries'
 
-export class BridgeWrapper extends ModuleWrapper implements Bridge {
+export class BridgeWrapper extends ModuleWrapper<BridgeModule> implements BridgeModule {
+  public get targetResolver() {
+    return this.module.targetResolver
+  }
+
   async connect(uri?: string): Promise<boolean> {
     const queryPayload = PayloadWrapper.parse<XyoBridgeQuery>({ schema: XyoBridgeConnectQuerySchema, uri })
     await this.sendQuery(queryPayload)
@@ -16,4 +30,36 @@ export class BridgeWrapper extends ModuleWrapper implements Bridge {
     await this.sendQuery(queryPayload)
     return true
   }
+
+  async targetDiscover(address: string): Promise<XyoPayload[]> {
+    const queryPayload = PayloadWrapper.parse<ModuleDiscoverQuery>({ schema: ModuleDiscoverQuerySchema })
+    return await this.sendTargetQuery(address, queryPayload)
+  }
+
+  async targetQuery<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(
+    address: string,
+    query: T,
+    payloads?: XyoPayload[],
+  ): Promise<ModuleQueryResult> {
+    return await this.module.targetQuery(address, query, payloads)
+  }
+
+  async targetQueryable(address: string, query: XyoQueryBoundWitness, payloads?: XyoPayload[], queryConfig?: ModuleConfig): Promise<boolean> {
+    return await this.module.targetQueryable(address, query, payloads, queryConfig)
+  }
+
+  async targetResolve(address: string, filter?: ModuleFilter) {
+    return await this.module.targetResolve(address, filter)
+  }
+
+  protected async sendTargetQuery<T extends XyoQuery | PayloadWrapper<XyoQuery>>(
+    address: string,
+    queryPayload: T,
+    payloads?: XyoPayloads,
+  ): Promise<XyoPayload[]> {
+    const query = await this.bindQuery(queryPayload, payloads)
+    const result = await this.module.targetQuery(address, query[0], query[1])
+    this.throwErrors(query, result)
+    return result[1]
+  }
 }

package/src/HttpBridge.ts

@@ -1,16 +1,17 @@
 import { assertEx } from '@xylabs/assert'
 import { Account } from '@xyo-network/account'
+import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
 import { XyoApiEnvelope } from '@xyo-network/api-models'
 import { AxiosError, AxiosJson } from '@xyo-network/axios'
 import {
   AbstractModule,
+  ModuleConfig,
   ModuleDiscoverQuery,
   ModuleDiscoverQuerySchema,
   ModuleFilter,
   ModuleParams,
   ModuleQueryResult,
   ModuleResolver,
-  ModuleWrapper,
   QueryBoundWitnessWrapper,
   XyoErrorBuilder,
   XyoQuery,
@@ -31,40 +32,37 @@ export interface XyoHttpBridgeParams<TConfig extends HttpBridgeConfig = HttpBrid
   axios?: AxiosJson
 }
 
-export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> extends AbstractModule<TConfig> implements BridgeModule {
+export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> extends AbstractModule<TConfig> implements BridgeModule<TConfig> {
+  private _targetQueries: Record<string, string[]> = {}
+  private _targetResolver: ModuleResolver
   private axios: AxiosJson
-  private remoteQueries: string[] = []
-  private remoteResolver: ModuleResolver
 
   protected constructor(params: XyoHttpBridgeParams<TConfig>) {
     super(params)
     this.axios = params.axios ?? new AxiosJson()
-    this.remoteResolver = new RemoteModuleResolver(this)
+    this._targetResolver = new RemoteModuleResolver(this)
   }
 
   public get nodeUri() {
     return assertEx(this.config?.nodeUri, 'Missing nodeUri')
   }
 
-  public override get queries() {
-    return [...super.queries, ...this.remoteQueries]
+  public get targetAddress() {
+    return assertEx(this.config?.targetAddress, 'targetAddress not set')
   }
 
-  public get targetAddress() {
-    return this.config?.targetAddress
+  public get targetResolver() {
+    return this._targetResolver
   }
 
   static override async create(params: XyoHttpBridgeParams): Promise<HttpBridge> {
     const result = (await super.create(params)) as HttpBridge
-    const moduleWrapper = ModuleWrapper.wrap(result)
-    const discover = await moduleWrapper.discover()
-    result.remoteQueries = compact(
+    const discover = await result.targetDiscover(params.config.targetAddress ?? '')
+    await Promise.all(
       discover.map((payload) => {
-        if (payload.schema === QuerySchema) {
-          const schemaPayload = payload as QueryPayload
-          return schemaPayload.query
-        } else {
-          return null
+        const addressPayload = payload as AddressPayload
+        if (addressPayload.schema === AddressSchema) {
+          return result.targetDiscover(addressPayload.address)
         }
       }),
     )
@@ -79,11 +77,6 @@ export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> ext
     return true
   }
 
-  override async discover() {
-    const queryPayload = PayloadWrapper.parse<ModuleDiscoverQuery>({ schema: ModuleDiscoverQuerySchema })
-    return (await this.forward(queryPayload))[1]
-  }
-
   override async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(query: T, payloads?: XyoPayload[]): Promise<ModuleQueryResult> {
     const wrapper = QueryBoundWitnessWrapper.parseQuery<XyoBridgeQuery>(query, payloads)
     const typedQuery = wrapper.query.payload
@@ -100,11 +93,7 @@ export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> ext
           break
         }
         default:
-          if (super.queries.find((schema) => schema === typedQuery.schema)) {
-            return await super.query(query, payloads)
-          } else {
-            return await this.forward(query, payloads)
-          }
+          return await super.query(query, payloads)
       }
     } catch (ex) {
       const error = ex as Error
@@ -114,13 +103,40 @@ export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> ext
   }
 
   override async resolve(filter?: ModuleFilter) {
-    return [...(await super.resolve(filter)), ...(await this.remoteResolver.resolve(filter))]
+    return [...(await super.resolve(filter)), ...(await this.targetResolver.resolve(filter))]
   }
 
-  protected async forward(query: XyoQuery, payloads: XyoPayload[] = []): Promise<ModuleQueryResult> {
+  async targetDiscover(address: string): Promise<XyoPayload[]> {
+    const queryPayload = PayloadWrapper.parse<ModuleDiscoverQuery>({ schema: ModuleDiscoverQuerySchema })
+    const discover = assertEx(await this.targetQuery(address, queryPayload), `Unable to resolve [${address}]`)[1]
+
+    this._targetQueries[address] = compact(
+      discover?.map((payload) => {
+        if (payload.schema === QuerySchema) {
+          const schemaPayload = payload as QueryPayload
+          return schemaPayload.query
+        } else {
+          return null
+        }
+      }) ?? [],
+    )
+
+    return discover
+  }
+
+  public targetQueries(address: string): string[] {
+    return assertEx(this._targetQueries[address], `targetConfig not set [${address}]`)
+  }
+
+  async targetQuery(address: string, query: XyoQuery, payloads: XyoPayload[] = []): Promise<ModuleQueryResult> {
     try {
       const boundQuery = await this.bindQuery(query, payloads)
-      const result = await this.axios.post<XyoApiEnvelope<ModuleQueryResult>>(`${this.nodeUri}/address/${this.targetAddress}`, boundQuery)
+      const path = `${this.nodeUri}/${address}`
+      const result = await this.axios.post<XyoApiEnvelope<ModuleQueryResult>>(path, boundQuery)
+      if (result.status >= 400) {
+        this.logger?.error(`targetQuery failed [${path}]`)
+        throw `targetQuery failed [${path}] [${result.status}]`
+      }
       return result.data.data
     } catch (ex) {
       const error = ex as AxiosError
@@ -129,4 +145,12 @@ export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> ext
       throw error
     }
   }
+
+  targetQueryable(_address: string, _query: XyoQueryBoundWitness, _payloads?: XyoPayload[], _queryConfig?: ModuleConfig): boolean {
+    throw 'targetQueryable not available'
+  }
+
+  async targetResolve(address: string, filter?: ModuleFilter) {
+    return await this.targetResolver.resolve(filter)
+  }
 }

package/src/HttpProxyModule.ts

@@ -0,0 +1,37 @@
+import { Module, ModuleConfig, ModuleConfigSchema, ModuleFilter, ModuleQueryResult, XyoQueryBoundWitness } from '@xyo-network/module'
+import { XyoPayload } from '@xyo-network/payload-model'
+
+import { HttpBridge } from './HttpBridge'
+
+export class HttpProxyModule implements Module {
+  constructor(protected readonly bridge: HttpBridge, protected readonly _address: string) {}
+
+  get address() {
+    return this._address
+  }
+
+  get config(): ModuleConfig {
+    return { schema: ModuleConfigSchema }
+  }
+
+  get queries() {
+    return this.bridge.targetQueries(this.address)
+  }
+
+  get resolver() {
+    return this.bridge.targetResolver
+  }
+
+  async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(query: T, payloads?: XyoPayload[]): Promise<ModuleQueryResult> {
+    return await this.bridge.targetQuery(this.address, query, payloads)
+  }
+
+  queryable(query: XyoQueryBoundWitness, payloads?: XyoPayload[], queryConfig?: ModuleConfig): boolean {
+    return this.bridge.targetQueryable(this.address, query, payloads, queryConfig)
+  }
+
+  /* Resolves a filter from the perspective of the module, including through the parent/gateway module */
+  async resolve(filter?: ModuleFilter): Promise<Module[]> {
+    return await this.bridge.targetResolve(this.address, filter)
+  }
+}

package/src/RemoteModuleResolver.ts

@@ -1,25 +1,14 @@
-import { assertEx } from '@xylabs/assert'
 import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
-import { AbstractModule, CompositeModuleResolver, ModuleWrapper } from '@xyo-network/module'
+import { CompositeModuleResolver } from '@xyo-network/module'
 import { Module, ModuleFilter } from '@xyo-network/module-model'
 import compact from 'lodash/compact'
 import flatten from 'lodash/flatten'
 
 import { HttpBridge } from './HttpBridge'
-import { HttpBridgeConfigSchema } from './HttpBridgeConfig'
-
-interface LocalModuleFilter {
-  config?: string[]
-  query?: string[][]
-}
-
-interface RemoteModuleFilter {
-  address?: string[]
-  name?: string[]
-}
+import { HttpProxyModule } from './HttpProxyModule'
 
 export class RemoteModuleResolver extends CompositeModuleResolver {
-  private resolvedModules: Record<string, HttpBridge> = {}
+  private resolvedModules: Record<string, HttpProxyModule> = {}
 
   // TODO: Allow optional ctor param for supplying address for nested Nodes
   // protected readonly address?: string,
@@ -44,22 +33,12 @@ export class RemoteModuleResolver extends CompositeModuleResolver {
     throw new Error('Method not implemented.')
   }
 
-  async resolve(filter?: ModuleFilter): Promise<AbstractModule[]> {
-    const mods = await Promise.all(flatten(await this.resolveRemoteModules(filter)))
-    return this.filterLocalModules(mods, filter)
-  }
-
-  private filterLocalModules(mods: AbstractModule[], filter?: LocalModuleFilter): AbstractModule[] {
-    // TODO: Handle filter?.query
-    if (filter?.query) throw new Error('Filtering by query not yet implemented by this resolver')
-    const config = filter?.config
-    const filtered = config?.length ? mods.filter((mod) => config.includes(mod.config.schema)) : mods
-    return filtered
+  async resolve(filter?: ModuleFilter): Promise<HttpProxyModule[]> {
+    return await Promise.all(flatten(await this.resolveRemoteModules(filter)))
   }
 
   private async getRemoteAddresses() {
-    const nodeWrapper = assertEx(ModuleWrapper.wrap(this.bridge), 'nodeUri can not be wrapped')
-    const discover = await nodeWrapper.discover()
+    const discover = await this.bridge.targetDiscover('')
     return compact(
       discover.map((payload) => {
         if (payload.schema === AddressSchema) {
@@ -72,32 +51,25 @@ export class RemoteModuleResolver extends CompositeModuleResolver {
     )
   }
 
-  private async resolveByAddress(targetAddress: string): Promise<HttpBridge> {
+  private resolveByAddress(targetAddress: string): HttpProxyModule | undefined {
     const cached = this.resolvedModules[targetAddress]
     if (cached) return cached
-    const mod = await HttpBridge.create({
-      config: { nodeUri: this.bridge.nodeUri, schema: HttpBridgeConfigSchema, targetAddress },
-    })
+    const mod = new HttpProxyModule(this.bridge, targetAddress)
     this.resolvedModules[targetAddress] = mod
     return mod
   }
 
-  private async resolveByName(name: string): Promise<HttpBridge> {
+  private resolveByName(name: string): HttpProxyModule | undefined {
     const cached = this.resolvedModules[name]
     if (cached) return cached
-    const mod = await HttpBridge.create({
-      config: { name, nodeUri: this.bridge.nodeUri, schema: HttpBridgeConfigSchema },
-    })
-    this.resolvedModules[name] = mod
-    this.resolvedModules[mod.address] = mod
-    return mod
+    return undefined
   }
 
-  private async resolveRemoteModules(filter?: RemoteModuleFilter): Promise<HttpBridge[]> {
+  private async resolveRemoteModules(filter?: ModuleFilter): Promise<HttpProxyModule[]> {
     const addresses = filter ? filter?.address : await this.getRemoteAddresses()
     const names = filter?.name
-    const byAddress = await Promise.all(addresses?.map((address) => this.resolveByAddress(address)) ?? [])
-    const byName = await Promise.all(names?.map((name) => this.resolveByName(name)) ?? [])
+    const byAddress = compact(await Promise.all(addresses?.map((address) => this.resolveByAddress(address)) ?? []))
+    const byName = compact(await Promise.all(names?.map((name) => this.resolveByName(name)) ?? []))
     return [...byAddress, ...byName]
   }
 }

package/src/spec/HttpBridge.spec.ts

@@ -1,3 +1,4 @@
+import { assertEx } from '@xylabs/assert'
 import { AxiosJson } from '@xyo-network/axios'
 import { NodeWrapper } from '@xyo-network/node'
 
@@ -6,12 +7,15 @@ import { HttpBridgeConfigSchema } from '../HttpBridgeConfig'
 
 test('HttpBridge', async () => {
   const nodeUri = `${process.env.API_DOMAIN}` ?? 'http://localhost:8080'
+  const targetAddress = ''
 
   const bridge = await HttpBridge.create({
     axios: new AxiosJson(),
-    config: { nodeUri, schema: HttpBridgeConfigSchema, targetAddress: '5111228f724a066ac060fe2e6c8bbaae44b107d5' },
+    config: { nodeUri: `${nodeUri}/node`, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true }, targetAddress },
   })
-  const wrapper = NodeWrapper.wrap(bridge)
+  const modules = await bridge.resolve()
+  const rootNode = assertEx(modules[0])
+  const wrapper = NodeWrapper.wrap(rootNode)
   const description = await wrapper.describe()
   expect(description.children).toBeArray()
   expect(description.children?.length).toBeGreaterThan(0)