@xyo-network/bridge 2.46.2 → 2.46.4

package/src/RemoteModuleResolver.ts

@@ -0,0 +1,103 @@
+import { assertEx } from '@xylabs/assert'
+import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
+import { AbstractModule, CompositeModuleResolver, ModuleWrapper } 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[]
+}
+
+export class RemoteModuleResolver extends CompositeModuleResolver {
+  private resolvedModules: Record<string, HttpBridge> = {}
+
+  // TODO: Allow optional ctor param for supplying address for nested Nodes
+  // protected readonly address?: string,
+  constructor(protected readonly bridge: HttpBridge) {
+    super()
+  }
+
+  public get isModuleResolver(): boolean {
+    return true
+  }
+
+  add(module: Module, name?: string | undefined): this
+  add(module: Module[], name?: string[] | undefined): this
+  add(module: Module | Module[], name?: string | string[] | undefined): this
+  add(_module: unknown, _name?: unknown): this {
+    throw new Error('Method not implemented.')
+  }
+
+  remove(name: string | string[]): this
+  remove(address: string | string[]): this
+  remove(_address: unknown): this {
+    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
+  }
+
+  private async getRemoteAddresses() {
+    const nodeWrapper = assertEx(ModuleWrapper.wrap(this.bridge), 'nodeUri can not be wrapped')
+    const discover = await nodeWrapper.discover()
+    return compact(
+      discover.map((payload) => {
+        if (payload.schema === AddressSchema) {
+          const schemaPayload = payload as AddressPayload
+          return schemaPayload.address
+        } else {
+          return null
+        }
+      }),
+    )
+  }
+
+  private async resolveByAddress(targetAddress: string): Promise<HttpBridge> {
+    const cached = this.resolvedModules[targetAddress]
+    if (cached) return cached
+    const mod = await HttpBridge.create({
+      config: { nodeUri: this.bridge.nodeUri, schema: HttpBridgeConfigSchema, targetAddress },
+    })
+    this.resolvedModules[targetAddress] = mod
+    return mod
+  }
+
+  private async resolveByName(name: string): Promise<HttpBridge> {
+    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
+  }
+
+  private async resolveRemoteModules(filter?: RemoteModuleFilter): Promise<HttpBridge[]> {
+    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)) ?? [])
+    return [...byAddress, ...byName]
+  }
+}

package/src/index.ts

@@ -2,5 +2,6 @@ export * from './AbstractBridge'
 export * from './BridgeWrapper'
 export * from './Config'
 export * from './HttpBridge'
+export * from './HttpBridgeConfig'
 export * from './PartialConfig'
 export * from './Queries'

package/src/spec/HttpBridge.spec.ts

@@ -1,26 +1,20 @@
-import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
-import { Axios } from '@xyo-network/axios'
-import { uuid } from '@xyo-network/core'
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+import { AxiosJson } from '@xyo-network/axios'
+import { NodeWrapper } from '@xyo-network/node'
 
-import { HttpBridgeConfigSchema, XyoHttpBridge } from '../HttpBridge'
+import { HttpBridge } from '../HttpBridge'
+import { HttpBridgeConfigSchema } from '../HttpBridgeConfig'
 
-test('XyoHttpBridge', async () => {
-  const nodeUri = `${process.env.API_DOMAIN}` ?? 'https://beta.api.archivist.xyo.network'
-  const targetAddress = 'temp'
+test('HttpBridge', async () => {
+  const nodeUri = `${process.env.API_DOMAIN}` ?? 'http://localhost:8080'
 
-  const bridge = await XyoHttpBridge.create({
-    axios: new Axios(),
-    config: { nodeUri, schema: HttpBridgeConfigSchema, targetAddress },
+  const bridge = await HttpBridge.create({
+    axios: new AxiosJson(),
+    config: { nodeUri, schema: HttpBridgeConfigSchema, targetAddress: '5111228f724a066ac060fe2e6c8bbaae44b107d5' },
   })
-  const wrapper = new ArchivistWrapper(bridge)
-  const debugPayload = {
-    nonce: uuid(),
-    schema: 'network.xyo.debug',
-  }
-  const result = await wrapper.insert([debugPayload])
-  console.log(result)
-  //expect(result).toBeDefined()
-  await wrapper.get([new PayloadWrapper(debugPayload).hash])
-  //expect(result2).toBeDefined()
+  const wrapper = NodeWrapper.wrap(bridge)
+  const description = await wrapper.describe()
+  expect(description.children).toBeArray()
+  expect(description.children?.length).toBeGreaterThan(0)
+  expect(description.queries).toBeArray()
+  expect(description.queries?.length).toBeGreaterThan(0)
 })