@xyo-network/bridge-http 2.102.0

package/src/HttpBridgeModuleResolver.ts

@@ -0,0 +1,88 @@
+import { assertEx } from '@xylabs/assert'
+import { Address, isAddress } from '@xylabs/hex'
+import { AbstractBridgeModuleResolver, BridgeModuleResolverParams, wrapModuleWithType } from '@xyo-network/abstract-bridge'
+import { Account } from '@xyo-network/account'
+import { ConfigPayload, ConfigSchema } from '@xyo-network/config-payload-plugin'
+import {
+  asModuleInstance,
+  ModuleConfig,
+  ModuleConfigSchema,
+  ModuleFilterOptions,
+  ModuleIdentifier,
+  ModuleInstance,
+  ResolveHelper,
+} from '@xyo-network/module-model'
+
+import { BridgeQuerySender, HttpModuleProxy, HttpModuleProxyParams } from './ModuleProxy'
+
+export interface HttpBridgeModuleResolverParams extends BridgeModuleResolverParams {
+  querySender: BridgeQuerySender
+  rootUrl: string
+}
+
+export class HttpBridgeModuleResolver<
+  T extends HttpBridgeModuleResolverParams = HttpBridgeModuleResolverParams,
+> extends AbstractBridgeModuleResolver<T> {
+  get querySender() {
+    return this.params.querySender
+  }
+
+  moduleUrl(address: Address) {
+    return new URL(address, this.params.rootUrl)
+  }
+
+  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T[]> {
+    const parentResult = await super.resolveHandler(id, options)
+    if (parentResult.length > 0) {
+      return parentResult
+    }
+    if (id === '*') {
+      return []
+    }
+    const idParts = id.split(':')
+    const untransformedFirstPart = assertEx(idParts.shift(), () => `Invalid module identifier: ${id}`)
+    const firstPart = await ResolveHelper.transformModuleIdentifier(untransformedFirstPart)
+    const moduleAddress = firstPart as Address
+    assertEx(isAddress(firstPart), () => `Invalid module address: ${firstPart}`)
+    const remainderParts = idParts.join(':')
+    const params: HttpModuleProxyParams = {
+      account: Account.randomSync(),
+      archiving: this.params.archiving,
+      config: { schema: ModuleConfigSchema },
+      host: this,
+      moduleAddress,
+      querySender: this.querySender,
+    }
+
+    this.logger?.debug(`creating HttpProxy [${moduleAddress}] ${id}`)
+
+    const proxy = new HttpModuleProxy<T, HttpModuleProxyParams>(params)
+    //calling state here to get the config
+    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 wrapped = assertEx(wrapModuleWithType(proxy, Account.randomSync()) as unknown as T, () => `Failed to wrapModuleWithType [${id}]`)
+    const instance = assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
+    proxy.upResolver.add(instance)
+    proxy.downResolver.add(instance)
+
+    if (remainderParts.length > 0) {
+      const result = await wrapped.resolve<T>(remainderParts, options)
+      return result ? [result] : []
+    }
+
+    //console.log(`resolved: ${proxy.address} [${wrapped.constructor.name}] [${as.constructor.name}]`)
+    return [instance]
+  }
+}

package/src/ModuleProxy/ModuleProxy.ts

@@ -0,0 +1,41 @@
+import { Address } from '@xylabs/hex'
+import { AbstractModuleProxy, ModuleProxyParams } from '@xyo-network/abstract-bridge'
+import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
+import { AttachableModuleInstance, ModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
+import { Payload } from '@xyo-network/payload-model'
+
+export interface BridgeQuerySender {
+  sendBridgeQuery: <TOut extends Payload = Payload, TQuery extends QueryBoundWitness = QueryBoundWitness, TIn extends Payload = Payload>(
+    targetAddress: Address,
+    query: TQuery,
+    payloads?: TIn[],
+  ) => Promise<ModuleQueryResult<TOut>>
+}
+
+export type HttpModuleProxyParams = ModuleProxyParams & {
+  querySender: BridgeQuerySender
+}
+
+export class HttpModuleProxy<
+    TWrappedModule extends ModuleInstance = ModuleInstance,
+    TParams extends Omit<HttpModuleProxyParams, 'config'> & { config: TWrappedModule['config'] } = Omit<HttpModuleProxyParams, 'config'> & {
+      config: TWrappedModule['config']
+    },
+  >
+  extends AbstractModuleProxy<TWrappedModule, TParams>
+  implements AttachableModuleInstance<TParams, TWrappedModule['eventData']>
+{
+  static createCount = 0
+
+  constructor(params: TParams) {
+    HttpModuleProxy.createCount = HttpModuleProxy.createCount + 1
+    if (Math.floor(HttpModuleProxy.createCount / 10) === HttpModuleProxy.createCount / 10) {
+      console.log(`HttpModuleProxy.createCount: ${HttpModuleProxy.createCount}`)
+    }
+    super(params)
+  }
+
+  async proxyQueryHandler<T extends QueryBoundWitness = QueryBoundWitness>(query: T, payloads: Payload[] = []): Promise<ModuleQueryResult> {
+    return await this.params.querySender.sendBridgeQuery(this.params.moduleAddress, query, payloads)
+  }
+}

package/src/ModuleProxy/index.ts

@@ -0,0 +1 @@
+export * from './ModuleProxy'

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './HttpBridge'
+export * from './HttpBridgeConfig'

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}