@xyo-network/bridge-http 2.105.1 → 2.106.0-rc.2

package/src/HttpBridgeBase.ts

@@ -16,15 +16,16 @@ import {
   QuerySendFinishedEventArgs,
   QuerySendStartedEventArgs,
 } from '@xyo-network/bridge-model'
-import { NodeManifestPayload, NodeManifestPayloadSchema } from '@xyo-network/manifest-model'
+import { ModuleManifestPayload, NodeManifestPayload, NodeManifestPayloadSchema } from '@xyo-network/manifest-model'
 import {
   AnyConfigSchema,
   creatableModule,
+  ModuleIdentifier,
   ModuleInstance,
   ModuleQueryResult,
-  ModuleResolverInstance,
   ModuleStateQuery,
   ModuleStateQuerySchema,
+  ResolveHelper,
 } from '@xyo-network/module-model'
 import { asAttachableNodeInstance } from '@xyo-network/node-model'
 import { isPayloadOfSchemaType, Payload, Schema, WithMeta } from '@xyo-network/payload-model'
@@ -103,6 +104,28 @@ export class HttpBridgeBase<TParams extends HttpBridgeParams> extends AbstractBr
     return this._resolver
   }
 
+  async connect(id: ModuleIdentifier): Promise<Address | undefined> {
+    const transformedId = assertEx(await ResolveHelper.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`)
+    //check if already connected
+    const existingInstance = await this.resolve<ModuleInstance>(transformedId)
+    if (existingInstance) {
+      return existingInstance.address
+    }
+
+    //use the resolver to create the proxy instance
+    const [instance] = await this.resolver.resolveHandler<ModuleInstance>(id)
+    return this.connectInstance(instance)
+  }
+
+  async disconnect(id: ModuleIdentifier): Promise<Address | undefined> {
+    const transformedId = assertEx(await ResolveHelper.transformModuleIdentifier(id), () => `Unable to transform module identifier: ${id}`)
+    const instance = await this.resolve<ModuleInstance>(transformedId)
+    if (instance) {
+      this.downResolver.remove(instance.address)
+      return instance.address
+    }
+  }
+
   override exposeHandler(_id: string, _options?: BridgeExposeOptions | undefined): Promisable<ModuleInstance[]> {
     throw new Error('Unsupported')
   }
@@ -178,6 +201,24 @@ export class HttpBridgeBase<TParams extends HttpBridgeParams> extends AbstractBr
     throw new Error('Unsupported')
   }
 
+  protected connectInstance(instance?: ModuleInstance): Address | undefined {
+    if (instance) {
+      this.downResolver.add(instance)
+      /*if (maxDepth > 0) {
+        const node = asNodeInstance(instance)
+        if (node) {
+          const state = await node.state()
+          const children = (state?.filter(isPayloadOfSchemaType<AddressPayload>(AddressSchema)).map((s) => s.address) ?? []).filter(
+            (a) => a !== instance.address,
+          )
+          await Promise.all(children.map((child) => this.connect(child, maxDepth - 1)))
+        }
+      }*/
+      this.logger?.log(`Connect: ${instance.id}`)
+      return instance.address
+    }
+  }
+
   private async getRootState() {
     const queryPayload: ModuleStateQuery = { schema: ModuleStateQuerySchema }
     const boundQuery = await this.bindQuery(queryPayload)
@@ -197,16 +238,22 @@ export class HttpBridgeBase<TParams extends HttpBridgeParams> extends AbstractBr
     }
   }
 
-  private async resolveRootNode(nodeManifest: NodeManifestPayload): Promise<ModuleInstance[]> {
+  private async resolveRootNode(nodeManifest: ModuleManifestPayload): Promise<ModuleInstance[]> {
     const rootModule = assertEx(
-      (await this.resolver.resolveHandler(assertEx(nodeManifest.status?.address, () => 'Root has no address'))).at(0),
+      (
+        await this.resolver.resolveHandler(
+          assertEx(nodeManifest.status?.address, () => 'Root has no address'),
+          undefined,
+          { manifest: nodeManifest },
+        )
+      ).at(0),
       () => `Root not found [${nodeManifest.status?.address}]`,
     )
     assertEx(rootModule.constructor.name !== 'HttpModuleProxy', () => 'rootModule is not a Wrapper')
     const rootNode = asAttachableNodeInstance(rootModule, 'Root modules is not a node')
     if (rootNode) {
       this.logger.debug(`rootNode: ${rootNode.id}`)
-      this.downResolver.addResolver(rootNode as unknown as ModuleResolverInstance)
+      this.connectInstance(rootNode)
       return [rootNode]
     }
     return []

package/src/HttpBridgeModuleResolver.ts

@@ -12,6 +12,8 @@ import {
   ModuleInstance,
   ResolveHelper,
 } from '@xyo-network/module-model'
+import { Mutex } from 'async-mutex'
+import { LRUCache } from 'lru-cache'
 
 import { BridgeQuerySender, HttpModuleProxy, HttpModuleProxyParams } from './ModuleProxy'
 
@@ -23,6 +25,9 @@ export interface HttpBridgeModuleResolverParams extends BridgeModuleResolverPara
 export class HttpBridgeModuleResolver<
   T extends HttpBridgeModuleResolverParams = HttpBridgeModuleResolverParams,
 > extends AbstractBridgeModuleResolver<T> {
+  protected _resolvedCache = new LRUCache<Address, ModuleInstance>({ max: 1000 })
+  protected _resolvedCacheMutex = new Mutex()
+
   get querySender() {
     return this.params.querySender
   }
@@ -31,37 +36,44 @@ export class HttpBridgeModuleResolver<
     return new URL(address, this.params.rootUrl)
   }
 
-  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T[]> {
+  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(
+    id: ModuleIdentifier,
+    options?: ModuleFilterOptions<T>,
+    params?: Partial<HttpModuleProxyParams>,
+  ): 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 untransformedFirstPart = assertEx(idParts.shift(), () => 'Missing module identifier')
     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(),
-      additionalSigners: this.params.additionalSigners,
-      archiving: this.params.archiving,
-      config: { schema: ModuleConfigSchema },
-      host: this,
-      moduleAddress,
-      onQuerySendFinished: this.params.onQuerySendFinished,
-      onQuerySendStarted: this.params.onQuerySendStarted,
-      querySender: this.querySender,
-    }
+    const instance: T = await this._resolvedCacheMutex.runExclusive(async () => {
+      const cachedMod = this._resolvedCache.get(firstPart as Address)
+      if (cachedMod) {
+        const result = idParts.length <= 0 ? cachedMod : cachedMod.resolve(remainderParts, { ...options, maxDepth: (options?.maxDepth ?? 5) - 1 })
+        return result as T
+      }
+      const account = Account.randomSync()
+      const finalParams: HttpModuleProxyParams = {
+        account,
+        archiving: this.params.archiving,
+        config: { schema: ModuleConfigSchema },
+        host: this,
+        moduleAddress: firstPart as Address,
+        onQuerySendFinished: this.params.onQuerySendFinished,
+        onQuerySendStarted: this.params.onQuerySendStarted,
+        querySender: this.params.querySender,
+        ...params,
+      }
 
-    this.logger?.debug(`creating HttpProxy [${moduleAddress}] ${id}`)
+      this.logger?.debug(`creating HttpProxy [${firstPart}] ${id}`)
+      console.log(`creating HttpProxy [${firstPart}] ${id}`)
+
+      const proxy = new HttpModuleProxy<T, HttpModuleProxyParams>(finalParams)
 
-    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
@@ -71,21 +83,16 @@ export class HttpBridgeModuleResolver<
         ) 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(`created HttpProxy [${firstPart}] ${proxy.id}`)
 
-    //console.log(`resolved: ${proxy.address} [${wrapped.constructor.name}] [${as.constructor.name}]`)
-    return [instance]
+      await proxy.start?.()
+      const wrapped = wrapModuleWithType(proxy, account) as unknown as T
+      assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
+      this._resolvedCache.set(wrapped.address, wrapped)
+      return wrapped as ModuleInstance as T
+    })
+    const result = remainderParts.length > 0 ? await instance.resolve(remainderParts, options) : instance
+    return result ? [result] : []
   }
 }

package/src/ModuleProxy/ModuleProxy.ts

@@ -1,8 +1,19 @@
+import { assertEx } from '@xylabs/assert'
+import { exists } from '@xylabs/exists'
 import { forget } from '@xylabs/forget'
-import { Address } from '@xylabs/hex'
+import { Address, isAddress } from '@xylabs/hex'
 import { QueryBoundWitness } from '@xyo-network/boundwitness-model'
 import { AbstractModuleProxy, ModuleProxyParams } from '@xyo-network/bridge-abstract'
-import { AttachableModuleInstance, ModuleInstance, ModuleQueryResult } from '@xyo-network/module-model'
+import {
+  AttachableModuleInstance,
+  ModuleFilter,
+  ModuleFilterOptions,
+  ModuleIdentifier,
+  ModuleInstance,
+  ModuleQueryResult,
+  ResolveHelper,
+  ResolveHelperConfig,
+} from '@xyo-network/module-model'
 import { Payload } from '@xyo-network/payload-model'
 
 export interface BridgeQuerySender {
@@ -46,4 +57,59 @@ export class HttpModuleProxy<
     }
     return result
   }
+
+  override async publicChildren(): Promise<ModuleInstance[]> {
+    return (
+      await Promise.all(
+        Object.values(await this.childAddressMap())
+          .filter(exists)
+          .map((address) => this.resolve(address)),
+      )
+    ).filter(exists)
+  }
+
+  /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
+  override async resolve(): Promise<ModuleInstance[]>
+  override async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
+  override async resolve<T extends ModuleInstance = ModuleInstance>(filter: ModuleFilter, options?: ModuleFilterOptions<T>): Promise<T[]>
+  override async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
+  /** @deprecated use '*' if trying to resolve all */
+  override async resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter, options?: ModuleFilterOptions<T>): Promise<T[]>
+  override async resolve<T extends ModuleInstance = ModuleInstance>(
+    idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
+    options: ModuleFilterOptions<T> = {},
+  ): Promise<T | T[] | undefined> {
+    const config: ResolveHelperConfig = {
+      address: this.address,
+      dead: this.dead,
+      downResolver: this.downResolver,
+      logger: this.logger,
+      module: this,
+      transformers: this.moduleIdentifierTransformers,
+      upResolver: this.upResolver,
+    }
+    if (idOrFilter === '*') {
+      return (await this.publicChildren()) as T[]
+    }
+    switch (typeof idOrFilter) {
+      case 'string': {
+        const parts = idOrFilter.split(':')
+        const first = assertEx(parts.shift(), () => 'Missing first')
+        const remainingPath = parts.join(':')
+        const address =
+          isAddress(first) ? first
+          : this.id === first ? this.address
+          : this.childAddressByName(first)
+        if (!address) return undefined
+        const firstInstance = (await this.params.host.resolve(address)) as ModuleInstance | undefined
+        return (remainingPath ? await firstInstance?.resolve(remainingPath) : firstInstance) as T | undefined
+      }
+      case 'object': {
+        return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
+      }
+      default: {
+        return (await ResolveHelper.resolve(config, idOrFilter, options)).filter((mod) => mod.address !== this.address)
+      }
+    }
+  }
 }