@xyo-network/bridge 2.46.4 → 2.47.1

package/src/HttpBridge.ts

@@ -1,132 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-import { Account } from '@xyo-network/account'
-import { XyoApiEnvelope } from '@xyo-network/api-models'
-import { AxiosError, AxiosJson } from '@xyo-network/axios'
-import {
-  AbstractModule,
-  ModuleDiscoverQuery,
-  ModuleDiscoverQuerySchema,
-  ModuleFilter,
-  ModuleParams,
-  ModuleQueryResult,
-  ModuleResolver,
-  ModuleWrapper,
-  QueryBoundWitnessWrapper,
-  XyoErrorBuilder,
-  XyoQuery,
-  XyoQueryBoundWitness,
-} from '@xyo-network/module'
-import { XyoPayload } from '@xyo-network/payload-model'
-import { PayloadWrapper } from '@xyo-network/payload-wrapper'
-import { Promisable } from '@xyo-network/promise'
-import { QueryPayload, QuerySchema } from '@xyo-network/query-payload-plugin'
-import compact from 'lodash/compact'
-
-import { BridgeModule } from './Bridge'
-import { HttpBridgeConfig } from './HttpBridgeConfig'
-import { XyoBridgeConnectQuerySchema, XyoBridgeDisconnectQuerySchema, XyoBridgeQuery } from './Queries'
-import { RemoteModuleResolver } from './RemoteModuleResolver'
-
-export interface XyoHttpBridgeParams<TConfig extends HttpBridgeConfig = HttpBridgeConfig> extends ModuleParams<TConfig> {
-  axios?: AxiosJson
-}
-
-export class HttpBridge<TConfig extends HttpBridgeConfig = HttpBridgeConfig> extends AbstractModule<TConfig> implements BridgeModule {
-  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)
-  }
-
-  public get nodeUri() {
-    return assertEx(this.config?.nodeUri, 'Missing nodeUri')
-  }
-
-  public override get queries() {
-    return [...super.queries, ...this.remoteQueries]
-  }
-
-  public get targetAddress() {
-    return this.config?.targetAddress
-  }
-
-  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(
-      discover.map((payload) => {
-        if (payload.schema === QuerySchema) {
-          const schemaPayload = payload as QueryPayload
-          return schemaPayload.query
-        } else {
-          return null
-        }
-      }),
-    )
-    return result
-  }
-
-  connect(): Promisable<boolean> {
-    return true
-  }
-
-  disconnect(): Promisable<boolean> {
-    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
-    const queryAccount = new Account()
-    const resultPayloads: XyoPayload[] = []
-    try {
-      switch (typedQuery.schema) {
-        case XyoBridgeConnectQuerySchema: {
-          await this.connect()
-          break
-        }
-        case XyoBridgeDisconnectQuerySchema: {
-          await this.disconnect()
-          break
-        }
-        default:
-          if (super.queries.find((schema) => schema === typedQuery.schema)) {
-            return await super.query(query, payloads)
-          } else {
-            return await this.forward(query, payloads)
-          }
-      }
-    } catch (ex) {
-      const error = ex as Error
-      resultPayloads.push(new XyoErrorBuilder([wrapper.hash], error.message).build())
-    }
-    return await this.bindResult(resultPayloads, queryAccount)
-  }
-
-  override async resolve(filter?: ModuleFilter) {
-    return [...(await super.resolve(filter)), ...(await this.remoteResolver.resolve(filter))]
-  }
-
-  protected async forward(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)
-      return result.data.data
-    } catch (ex) {
-      const error = ex as AxiosError
-      this.logger?.error(`Error Status: ${error.status}`)
-      this.logger?.error(`Error Cause: ${JSON.stringify(error.cause, null, 2)}`)
-      throw error
-    }
-  }
-}

package/src/HttpBridgeConfig.ts

@@ -1,14 +0,0 @@
-import { XyoPayload } from '@xyo-network/payload-model'
-
-import { BridgeConfig } from './Config'
-
-export type HttpBridgeConfigSchema = 'network.xyo.bridge.http.config'
-export const HttpBridgeConfigSchema: HttpBridgeConfigSchema = 'network.xyo.bridge.http.config'
-
-export type HttpBridgeConfig<TConfig extends XyoPayload = XyoPayload> = BridgeConfig<
-  {
-    nodeUri: string
-    schema: HttpBridgeConfigSchema
-    targetAddress?: string
-  } & TConfig
->

package/src/PartialConfig.ts

@@ -1,5 +0,0 @@
-import { PartialModuleConfig } from '@xyo-network/module'
-
-import { BridgeConfig } from './Config'
-
-export type PartialBridgeConfig<T extends BridgeConfig> = PartialModuleConfig<T>

package/src/Queries/Connect.ts

@@ -1,9 +0,0 @@
-import { XyoQuery } from '@xyo-network/module-model'
-
-export type XyoBridgeConnectQuerySchema = 'network.xyo.query.bridge.connect'
-export const XyoBridgeConnectQuerySchema: XyoBridgeConnectQuerySchema = 'network.xyo.query.bridge.connect'
-
-export type XyoBridgeConnectQuery = XyoQuery<{
-  schema: XyoBridgeConnectQuerySchema
-  uri?: string
-}>

package/src/Queries/Disconnect.ts

@@ -1,9 +0,0 @@
-import { XyoQuery } from '@xyo-network/module-model'
-
-export type XyoBridgeDisconnectQuerySchema = 'network.xyo.query.bridge.disconnect'
-export const XyoBridgeDisconnectQuerySchema: XyoBridgeDisconnectQuerySchema = 'network.xyo.query.bridge.disconnect'
-
-export type XyoBridgeDisconnectQuery = XyoQuery<{
-  schema: XyoBridgeDisconnectQuerySchema
-  uri?: string
-}>

package/src/Queries/index.ts

@@ -1,10 +0,0 @@
-import { ModuleQuery, XyoQuery } from '@xyo-network/module-model'
-
-import { XyoBridgeConnectQuery } from './Connect'
-import { XyoBridgeDisconnectQuery } from './Disconnect'
-
-export * from './Connect'
-export * from './Disconnect'
-
-export type XyoBridgeQueryBase = XyoBridgeConnectQuery | XyoBridgeDisconnectQuery
-export type XyoBridgeQuery<T extends XyoQuery | void = void> = ModuleQuery<T extends XyoQuery ? XyoBridgeQueryBase | T : XyoBridgeQueryBase>

package/src/RemoteModuleResolver.ts

@@ -1,103 +0,0 @@
-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/spec/HttpBridge.spec.ts

@@ -1,20 +0,0 @@
-import { AxiosJson } from '@xyo-network/axios'
-import { NodeWrapper } from '@xyo-network/node'
-
-import { HttpBridge } from '../HttpBridge'
-import { HttpBridgeConfigSchema } from '../HttpBridgeConfig'
-
-test('HttpBridge', async () => {
-  const nodeUri = `${process.env.API_DOMAIN}` ?? 'http://localhost:8080'
-
-  const bridge = await HttpBridge.create({
-    axios: new AxiosJson(),
-    config: { nodeUri, schema: HttpBridgeConfigSchema, targetAddress: '5111228f724a066ac060fe2e6c8bbaae44b107d5' },
-  })
-  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)
-})