@xyo-network/bridge 2.47.0 → 2.47.2

package/src/HttpBridge.ts

@@ -1,156 +0,0 @@
-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,
-  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<TConfig> {
-  private _targetQueries: Record<string, string[]> = {}
-  private _targetResolver: ModuleResolver
-  private axios: AxiosJson
-
-  protected constructor(params: XyoHttpBridgeParams<TConfig>) {
-    super(params)
-    this.axios = params.axios ?? new AxiosJson()
-    this._targetResolver = new RemoteModuleResolver(this)
-  }
-
-  public get nodeUri() {
-    return assertEx(this.config?.nodeUri, 'Missing nodeUri')
-  }
-
-  public get targetAddress() {
-    return assertEx(this.config?.targetAddress, 'targetAddress not set')
-  }
-
-  public get targetResolver() {
-    return this._targetResolver
-  }
-
-  static override async create(params: XyoHttpBridgeParams): Promise<HttpBridge> {
-    const result = (await super.create(params)) as HttpBridge
-    const discover = await result.targetDiscover(params.config.targetAddress ?? '')
-    await Promise.all(
-      discover.map((payload) => {
-        const addressPayload = payload as AddressPayload
-        if (addressPayload.schema === AddressSchema) {
-          return result.targetDiscover(addressPayload.address)
-        }
-      }),
-    )
-    return result
-  }
-
-  connect(): Promisable<boolean> {
-    return true
-  }
-
-  disconnect(): Promisable<boolean> {
-    return true
-  }
-
-  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:
-          return await super.query(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.targetResolver.resolve(filter))]
-  }
-
-  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 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
-      this.logger?.error(`Error Status: ${error.status}`)
-      this.logger?.error(`Error Cause: ${JSON.stringify(error.cause, null, 2)}`)
-      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/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/HttpProxyModule.ts

@@ -1,37 +0,0 @@
-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/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,75 +0,0 @@
-import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
-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 { HttpProxyModule } from './HttpProxyModule'
-
-export class RemoteModuleResolver extends CompositeModuleResolver {
-  private resolvedModules: Record<string, HttpProxyModule> = {}
-
-  // 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<HttpProxyModule[]> {
-    return await Promise.all(flatten(await this.resolveRemoteModules(filter)))
-  }
-
-  private async getRemoteAddresses() {
-    const discover = await this.bridge.targetDiscover('')
-    return compact(
-      discover.map((payload) => {
-        if (payload.schema === AddressSchema) {
-          const schemaPayload = payload as AddressPayload
-          return schemaPayload.address
-        } else {
-          return null
-        }
-      }),
-    )
-  }
-
-  private resolveByAddress(targetAddress: string): HttpProxyModule | undefined {
-    const cached = this.resolvedModules[targetAddress]
-    if (cached) return cached
-    const mod = new HttpProxyModule(this.bridge, targetAddress)
-    this.resolvedModules[targetAddress] = mod
-    return mod
-  }
-
-  private resolveByName(name: string): HttpProxyModule | undefined {
-    const cached = this.resolvedModules[name]
-    if (cached) return cached
-    return undefined
-  }
-
-  private async resolveRemoteModules(filter?: ModuleFilter): Promise<HttpProxyModule[]> {
-    const addresses = filter ? filter?.address : await this.getRemoteAddresses()
-    const names = filter?.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,24 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-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 targetAddress = ''
-
-  const bridge = await HttpBridge.create({
-    axios: new AxiosJson(),
-    config: { nodeUri: `${nodeUri}/node`, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true }, targetAddress },
-  })
-  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)
-  expect(description.queries).toBeArray()
-  expect(description.queries?.length).toBeGreaterThan(0)
-})