@xyo-network/bridge-http-express 3.14.0

package/src/HttpBridge.ts

@@ -0,0 +1,237 @@
+import { Server } from 'node:http'
+
+import { assertEx } from '@xylabs/assert'
+import { exists } from '@xylabs/exists'
+import {
+  asyncHandler,
+  customPoweredByHeader,
+  disableCaseSensitiveRouting,
+  disableExpressDefaultPoweredByHeader,
+  jsonBodyParser,
+  responseProfiler,
+  useRequestCounters,
+} from '@xylabs/express'
+import { Address } from '@xylabs/hex'
+import { toJsonString } from '@xylabs/object'
+import { isQueryBoundWitness, QueryBoundWitness } from '@xyo-network/boundwitness-model'
+import { HttpBridge, HttpBridgeConfig } from '@xyo-network/bridge-http'
+import {
+  BridgeExposeOptions, BridgeParams, BridgeUnexposeOptions,
+} from '@xyo-network/bridge-model'
+// import { standardResponses } from '@xyo-network/express-node-middleware'
+import {
+  AnyConfigSchema, creatableModule, ModuleInstance, ModuleQueryResult, resolveAddressToInstanceUp,
+} from '@xyo-network/module-model'
+import { Payload, Schema } from '@xyo-network/payload-model'
+import express, {
+  Application, Request, Response,
+} from 'express'
+import { StatusCodes } from 'http-status-codes'
+
+/**
+ * The type of the path parameters for the address path.
+ */
+type AddressPathParams = {
+  address: Address
+}
+
+/**
+ * The type of the request body for the address path.
+ */
+type PostAddressRequestBody = [QueryBoundWitness, undefined | Payload[]]
+
+// TODO: This does not match the error response shape of the legacy bridge BUT it its the
+// shape this bridge is currently returning.  Massage this into the standard
+// error shape constructed via middleware.
+/* type ErrorResponseBody = {
+  error: string
+} */
+
+export const HttpBridgeExpressConfigSchema = 'network.xyo.bridge.http.express.config' as const
+export type HttpBridgeExpressConfigSchema = typeof HttpBridgeExpressConfigSchema
+
+export interface HttpBridgeExpressConfig extends HttpBridgeConfig<{}, HttpBridgeExpressConfigSchema> {}
+
+export interface HttpBridgeExpressParams extends BridgeParams<AnyConfigSchema<HttpBridgeExpressConfig>> {}
+
+@creatableModule()
+export class HttpBridgeExpress<TParams extends HttpBridgeExpressParams> extends HttpBridge<TParams> {
+  static override readonly configSchemas: Schema[] = [...super.configSchemas, HttpBridgeExpressConfigSchema]
+  protected _app?: Application
+  protected _exposedModules: WeakRef<ModuleInstance>[] = []
+  protected _server?: Server
+
+  protected get app() {
+    if (!this._app) this._app = this.initializeApp()
+    return assertEx(this._app, () => 'App not initialized')
+  }
+
+  async exposeChild(mod: ModuleInstance, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
+    const { maxDepth = 5 } = options ?? {}
+    assertEx(this.config.host, () => 'Not configured as a host')
+    this._exposedModules.push(new WeakRef(mod))
+    const children = maxDepth > 0 ? ((await mod.publicChildren?.()) ?? []) : []
+    this.logger.log(`childrenToExpose [${mod.id}][${mod.address}]: ${toJsonString(children.map(child => child.id))}`)
+    const exposedChildren = (await Promise.all(children.map(child => this.exposeChild(child, { maxDepth: maxDepth - 1, required: false }))))
+      .flat()
+      .filter(exists)
+    const allExposed = [mod, ...exposedChildren]
+
+    for (const exposedMod of allExposed) this.logger?.log(`exposed: ${exposedMod.address} [${mod.id}]`)
+
+    return allExposed
+  }
+
+  override async exposeHandler(address: Address, options?: BridgeExposeOptions | undefined): Promise<ModuleInstance[]> {
+    const { required = true } = options ?? {}
+    const mod = await resolveAddressToInstanceUp(this, address)
+    if (required && !mod) {
+      throw new Error(`Unable to find required module: ${address}`)
+    }
+    if (mod) {
+      return this.exposeChild(mod, options)
+    }
+    return []
+  }
+
+  override exposedHandler(): Address[] {
+    return this._exposedModules.map(ref => ref.deref()?.address).filter(exists)
+  }
+
+  override async startHandler(): Promise<boolean> {
+    return (await super.startHandler()) && (await this.startHttpServer())
+  }
+
+  override async stopHandler(_timeout?: number | undefined): Promise<boolean> {
+    return (await super.stopHandler()) && (await this.stopHttpServer())
+  }
+
+  override async unexposeHandler(address: Address, options?: BridgeUnexposeOptions | undefined): Promise<ModuleInstance[]> {
+    const { maxDepth = 2, required = true } = options ?? {}
+    assertEx(this.config.host, () => 'Not configured as a host')
+    const mod = this._exposedModules.find(ref => ref.deref()?.address === address)?.deref()
+    assertEx(!required || mod, () => `Module not exposed: ${address}`)
+    this._exposedModules = this._exposedModules.filter(ref => ref.deref()?.address !== address)
+    if (mod) {
+      const children = maxDepth > 0 ? ((await mod.publicChildren?.()) ?? []) : []
+      const exposedChildren = (
+        await Promise.all(children.map(child => this.unexposeHandler(child.address, { maxDepth: maxDepth - 1, required: false })))
+      )
+        .flat()
+        .filter(exists)
+      return [mod, ...exposedChildren]
+    }
+    return []
+  }
+
+  protected async callLocalModule(address: Address, query: QueryBoundWitness, payloads: Payload[]): Promise<ModuleQueryResult | null> {
+    const mod = this._exposedModules.find(ref => ref.deref()?.address === address)?.deref()
+    return mod ? await mod.query(query, payloads) : null
+  }
+
+  protected async handleGet(req: Request<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>, res: Response) {
+    const { address } = req.params
+    try {
+      if (address == this.address) {
+        res.json(await this.stateQuery(this.account))
+      } else {
+        const mod = this._exposedModules.find(ref => ref.deref()?.address === address)?.deref()
+        // TODO: Use standard errors middleware
+        if (mod) {
+          res.json(await mod.stateQuery(this.account))
+        } else {
+          res.status(StatusCodes.NOT_FOUND).json({ error: 'Module not found' })
+        }
+      }
+    } catch (ex) {
+      // TODO: Sanitize message
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: (ex as Error).message })
+    }
+  }
+
+  protected async handlePost(req: Request<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>, res: Response) {
+    const { address } = req.params
+    const [bw, payloads = []] = Array.isArray(req.body) ? req.body : []
+    const query = isQueryBoundWitness(bw) ? bw : undefined
+    if (!query) {
+      // TODO: Use standard errors middleware
+      res.status(StatusCodes.BAD_REQUEST).json({ error: 'No query provided' })
+      return
+    }
+    try {
+      if (address == this.address) {
+        const result = await this.query(query, payloads)
+        return res.json(result)
+      } else {
+        const result = await this.callLocalModule(address, query, payloads)
+        // TODO: Use standard errors middleware
+        if (result === null) {
+          res.status(StatusCodes.NOT_FOUND).json({ error: 'Module not found' })
+        } else {
+          res.json(result)
+        }
+      }
+    } catch (ex) {
+      // TODO: Sanitize message
+      res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({ error: (ex as Error).message })
+    }
+  }
+
+  protected initializeApp() {
+    // Create the express app
+    const app = express()
+
+    // Add middleware
+    app.use(responseProfiler)
+    app.use(jsonBodyParser)
+    // removed for now since this causes a cycle
+    // app.use(standardResponses)
+    disableExpressDefaultPoweredByHeader(app)
+    app.use(customPoweredByHeader)
+    disableCaseSensitiveRouting(app)
+    useRequestCounters(app)
+
+    // Add routes
+    // Redirect all requests to the root to this module's address
+    app.get('/', (_req, res) => res.redirect(StatusCodes.MOVED_TEMPORARILY, `/${this.address}`))
+    app.post('/', (_req, res) => res.redirect(StatusCodes.TEMPORARY_REDIRECT, `/${this.address}`))
+
+    app.get<AddressPathParams, ModuleQueryResult>(
+      '/:address',
+
+      asyncHandler(async (req, res) => await this.handleGet(req, res)),
+    )
+    app.post<AddressPathParams, ModuleQueryResult, PostAddressRequestBody>(
+      '/:address',
+
+      asyncHandler(async (req, res) => { await this.handlePost(req, res) }),
+    )
+    return app
+  }
+
+  protected startHttpServer(): Promise<boolean> {
+    if (this.config.host) {
+      assertEx(!this._server, () => 'Server already started')
+      this._server = this.app.listen(this.config.host?.port ?? 3030)
+    }
+    return Promise.resolve(true)
+  }
+
+  protected stopHttpServer(): Promise<boolean> {
+    if (this.config.host) {
+      return new Promise((resolve, reject) => {
+        if (this._server) {
+          this._server.close((err) => {
+            if (err) {
+              reject(err)
+            } else {
+              this._server = undefined
+              resolve(true)
+            }
+          })
+        }
+      })
+    }
+    return Promise.resolve(true)
+  }
+}

package/src/index.ts

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

package/src/spec/HttpBridge.baddns.spec.ts

@@ -0,0 +1,42 @@
+import '@xylabs/vitest-extended'
+
+import { MemoryNode } from '@xyo-network/node-memory'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { HttpBridgeExpress, HttpBridgeExpressConfigSchema } from '../HttpBridge.ts'
+
+/**
+ * @group module
+ * @group bridge
+ */
+
+describe('HttpBridge', () => {
+  const baseUrl = 'https://sfjhskjdsfhdsk.com'
+
+  console.log(`HttpBridge:baseUrl ${baseUrl}`)
+  const cases = [
+    ['/', `${baseUrl}`],
+    /* ['/node', `${baseUrl}/node`], */
+  ]
+
+  it.each(cases)('HttpBridge: %s', async (_, nodeUrl) => {
+    const memNode = await MemoryNode.create({ account: 'random' })
+
+    const bridge = await HttpBridgeExpress.create({
+      account: 'random',
+      config: {
+        nodeUrl, schema: HttpBridgeExpressConfigSchema, security: { allowAnonymous: true },
+      },
+    })
+
+    await bridge?.start?.()
+
+    await memNode.register(bridge)
+    await memNode.attach(bridge.address, true)
+
+    const modules = await memNode.resolve('*')
+    expect(modules.length).toBe(2)
+  })
+})

package/src/spec/HttpBridge.copilot.spec.ts

@@ -0,0 +1,61 @@
+import '@xylabs/vitest-extended'
+
+import {
+  beforeEach,
+  describe, expect, it,
+} from 'vitest'
+
+import type { HttpBridgeExpressParams } from '../HttpBridge.ts'
+import { HttpBridgeExpress, HttpBridgeExpressConfigSchema } from '../HttpBridge.ts'
+
+describe('HttpBridgeExpress', () => {
+  let httpBridge: HttpBridgeExpress<HttpBridgeExpressParams>
+
+  beforeEach(async () => {
+    httpBridge = await HttpBridgeExpress.create({
+      account: 'random',
+      config: {
+        name: 'TestBridge', nodeUrl: 'http://localhost:8080', schema: HttpBridgeExpressConfigSchema, security: { allowAnonymous: true },
+      },
+    })
+  })
+
+  it('should create an instance of HttpBridgeExpress', () => {
+    expect(httpBridge).toBeInstanceOf(HttpBridgeExpress)
+  })
+
+  it('should have axios instance', () => {
+    expect(httpBridge.axios).toBeDefined()
+  })
+
+  it('should have nodeUrl defined', () => {
+    expect(httpBridge.clientUrl).toBe('http://localhost:8080')
+  })
+
+  it('should have resolver defined', () => {
+    expect(httpBridge.resolver).toBeDefined()
+  })
+
+  it('should return correct moduleUrl', () => {
+    const address = '0x1234'
+    expect(httpBridge.moduleUrl(address).toString()).toBe('http://localhost:8080/0x1234')
+  })
+
+  it('should throw error on call to exposeHandler', async () => {
+    try {
+      await httpBridge.exposeHandler('test')
+      expect('').toBe('exposeHandler should have thrown an error')
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error)
+    }
+  })
+
+  it('should throw error on call to unexposeHandler', async () => {
+    try {
+      await httpBridge.unexposeHandler('test')
+      expect('').toBe('unexposeHandler should have thrown an error')
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error)
+    }
+  })
+})

package/src/spec/HttpBridge.host-resolve.spec.ts

@@ -0,0 +1,86 @@
+import '@xylabs/vitest-extended'
+
+import { HttpBridge, HttpBridgeConfigSchema } from '@xyo-network/bridge-http'
+import type {
+  AsyncQueryBusIntersectConfig,
+  PubSubBridgeConfig,
+  PubSubBridgeParams,
+} from '@xyo-network/bridge-pub-sub'
+import {
+  PubSubBridge,
+  PubSubBridgeConfigSchema,
+} from '@xyo-network/bridge-pub-sub'
+import { MemoryNode } from '@xyo-network/node-memory'
+import { NodeConfigSchema } from '@xyo-network/node-model'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+/**
+ * @group module
+ * @group bridge
+ */
+
+describe.skip('HttpBridge with PubSubBridge', () => {
+  const httpBaseUrl = process.env.XNS_API_DOMAIN ?? 'https://beta.xns.xyo.network' ?? 'http://localhost:80'
+
+  console.log(`HttpBridge:baseUrl ${httpBaseUrl}`)
+  const cases = [
+    ['/', `${httpBaseUrl}`],
+    /* ['/node', `${baseUrl}/node`], */
+  ]
+
+  it.each(cases)('HttpBridge: %s', async (_, nodeUrl) => {
+    const memNode = await MemoryNode.create({ account: 'random', config: { name: 'MemNodeArie', schema: NodeConfigSchema } })
+    const intersect: AsyncQueryBusIntersectConfig = {
+      queries: { archivist: 'MemNodeArie:XNS:Intersect:QueryArchivist', boundWitnessDiviner: 'MemNodeArie:XNS:Intersect:QueryBoundWitnessDiviner' },
+      responses: {
+        archivist: 'MemNodeArie:XNS:Intersect:ResponseArchivist',
+        boundWitnessDiviner: 'MemNodeArie:XNS:Intersect:ResponseBoundWitnessDiviner',
+      },
+    }
+
+    const bridge = await HttpBridge.create({
+      account: 'random',
+      config: {
+        discoverRoots: 'start', name: 'TestBridge', nodeUrl, schema: HttpBridgeConfigSchema, security: { allowAnonymous: true },
+      },
+    })
+
+    await bridge?.start?.()
+    await memNode.register(bridge)
+    await memNode.attach(bridge?.address, true)
+
+    const config: PubSubBridgeConfig = {
+      client: { intersect }, host: { intersect }, name: 'PubSubBridgeArie', schema: PubSubBridgeConfigSchema,
+    }
+    const psParams: PubSubBridgeParams = { account: 'random', config }
+    const psBridge = await PubSubBridge.create(psParams)
+    await memNode.register(psBridge)
+    await memNode.attach(psBridge?.address, true)
+
+    await psBridge.start()
+    console.log(`Exposing: ${memNode.address}`)
+    await bridge.expose(memNode.address)
+
+    const subNodeInstance = await memNode?.resolve('PubSubBridgeArie')
+    expect(subNodeInstance).toBeDefined()
+
+    const testBridgeInstance = await memNode?.resolve('PubSubBridgeArie:TestBridge')
+    expect(testBridgeInstance).toBeDefined()
+
+    const xns1 = await testBridgeInstance?.resolve('XNS')
+    expect(xns1).toBeDefined()
+
+    const xns = await memNode?.resolve('PubSubBridgeArie:TestBridge:XNS')
+    expect(xns).toBeDefined()
+
+    const intersectNode = await memNode?.resolve('PubSubBridgeArie:TestBridge:XNS:Intersect')
+    expect(intersectNode).toBeDefined()
+
+    const queryArchivist = await memNode?.resolve('XNS:Intersect:QueryArchivist')
+    expect(queryArchivist?.id).toBe('QueryArchivist')
+
+    await psBridge.unexpose(memNode.address)
+  })
+})

package/src/spec/HttpBridge.host.spec.ts

@@ -0,0 +1,156 @@
+import '@xylabs/vitest-extended'
+
+import type { HttpBridgeConfig, HttpBridgeParams } from '@xyo-network/bridge-http'
+import { HttpBridge, HttpBridgeConfigSchema } from '@xyo-network/bridge-http'
+import type { ModuleDescriptionPayload } from '@xyo-network/module-model'
+import { ModuleDescriptionSchema } from '@xyo-network/module-model'
+import { MemoryNode } from '@xyo-network/node-memory'
+import { asAttachableNodeInstance } from '@xyo-network/node-model'
+import { isPayloadOfSchemaType } from '@xyo-network/payload-model'
+import { getPort } from 'get-port-please'
+import {
+  beforeAll,
+  beforeEach,
+  describe, expect, it,
+} from 'vitest'
+
+import type { HttpBridgeExpressConfig, HttpBridgeExpressParams } from '../HttpBridge.ts'
+import { HttpBridgeExpress, HttpBridgeExpressConfigSchema } from '../HttpBridge.ts'
+
+const account = 'random'
+const hostSchema = HttpBridgeExpressConfigSchema
+const clientSchema = HttpBridgeConfigSchema
+const security = { allowAnonymous: true }
+
+/**
+ * @group module
+ * @group bridge
+ */
+describe('HttpBridgeExpress', () => {
+  let port: number
+  let url: string
+  let hostBridge: HttpBridgeExpress<HttpBridgeExpressParams>
+  let clientBridge: HttpBridge<HttpBridgeParams>
+  let hostNode: MemoryNode
+  let clientNode: MemoryNode
+  let hostSibling: MemoryNode
+  let clientSibling: MemoryNode
+  let hostDescendent: MemoryNode
+  let clientDescendent: MemoryNode
+
+  beforeAll(async () => {
+    // Create Host/Client Nodes
+    hostNode = await MemoryNode.create({ account })
+    clientNode = await MemoryNode.create({ account })
+
+    // Create Host/Client Bridges
+    port = await getPort()
+    url = `http://localhost:${port}`
+
+    const host: HttpBridgeExpressConfig['host'] = { port }
+    const client: HttpBridgeConfig['client'] = { discoverRoots: 'start', url }
+    hostBridge = await HttpBridgeExpress.create({
+      account,
+      config: {
+        host, name: 'TestBridgeHost', schema: hostSchema, security,
+      },
+    })
+    clientBridge = await HttpBridge.create({
+      account,
+      config: {
+        client, name: 'TestBridgeClient', schema: clientSchema, security,
+      },
+    })
+
+    // Register Host/Client Bridges
+    await hostNode.register(hostBridge)
+    await hostNode.attach(hostBridge.address, true)
+    await clientNode.register(clientBridge)
+    await clientNode.attach(clientBridge.address, true)
+
+    // Create Host/Client Sibling Nodes
+    hostSibling = await MemoryNode.create({ account })
+    clientSibling = await MemoryNode.create({ account })
+
+    // Register Host/Client Siblings
+    await hostNode.register(hostSibling)
+    await hostNode.attach(hostSibling.address, true)
+    await clientNode.register(clientSibling)
+    await clientNode.attach(clientSibling.address, true)
+
+    // Create Host/Client Descendent Nodes
+    hostDescendent = await MemoryNode.create({ account })
+    clientDescendent = await MemoryNode.create({ account })
+
+    // Register Host/Client Siblings
+    await hostSibling.register(hostDescendent)
+    await hostSibling.attach(hostDescendent.address, true)
+    await clientSibling.register(clientDescendent)
+    await clientSibling.attach(clientDescendent.address, true)
+  })
+
+  describe('exposed module behavior', () => {
+    const cases: [string, () => MemoryNode][] = [
+      ['parent', () => hostNode],
+      ['sibling', () => hostSibling],
+      ['descendent', () => hostDescendent],
+    ]
+    describe.each(cases)('with %s module', (_, getSutModule) => {
+      let exposedMod: MemoryNode
+      beforeEach(() => {
+        exposedMod = getSutModule()
+      })
+      describe('before expose', () => {
+        it('should not be exposed', async () => {
+          expect(await hostBridge.exposed()).toBeEmpty()
+        })
+        it('should not be resolvable', async () => {
+          expect(await clientBridge.resolve(exposedMod.address)).toBeUndefined()
+        })
+      })
+      describe('after expose', () => {
+        beforeEach(async () => {
+          await hostBridge.expose(exposedMod.address)
+        })
+        it('should be exposed on host', async () => {
+          expect((await hostBridge.exposed()).includes(exposedMod.address)).toBeTrue()
+        })
+        it.skip('should be resolvable from client', async () => {
+          // TODO: Implement .connect on HttpBridgeExpress and call here before resolving
+          const result = await clientBridge.resolve(exposedMod.address)
+          expect(result).toBeDefined()
+          expect(asAttachableNodeInstance(result, () => `Failed to resolve correct object type [${result?.constructor.name}]`)).toBeDefined()
+        })
+        it.skip('should be queryable from client', async () => {
+          const bridgedHostedModule = await clientBridge.resolve(exposedMod.address)
+          expect(bridgedHostedModule).toBeDefined()
+
+          const bridgedHostedNode = asAttachableNodeInstance(
+            bridgedHostedModule,
+            () => `Failed to resolve correct object type [${bridgedHostedModule?.constructor.name}]`,
+          )
+
+          if (bridgedHostedNode) {
+            const state = await bridgedHostedNode.state()
+            const description = state.find(isPayloadOfSchemaType<ModuleDescriptionPayload>(ModuleDescriptionSchema))
+            expect(description?.children).toBeArray()
+            expect(description?.queries).toBeArray()
+            expect(description?.queries?.length).toBeGreaterThan(0)
+          }
+        })
+      })
+      describe('after unexpose', () => {
+        beforeEach(async () => {
+          await hostBridge.expose(exposedMod.address)
+          await hostBridge.unexpose(exposedMod.address)
+        })
+        it('should not be exposed', async () => {
+          expect(await hostBridge.exposed()).toBeEmpty()
+        })
+        it('should not be resolvable', async () => {
+          expect(await clientBridge.resolve(exposedMod.address)).toBeUndefined()
+        })
+      })
+    })
+  })
+})

package/src/spec/HttpBridge.legacy.spec.ts

@@ -0,0 +1,55 @@
+import '@xylabs/vitest-extended'
+
+import { MemoryNode } from '@xyo-network/node-memory'
+import type { NodeInstance } from '@xyo-network/node-model'
+import { NodeConfigSchema } from '@xyo-network/node-model'
+import {
+  describe, expect, it,
+} from 'vitest'
+
+import { HttpBridgeExpress, HttpBridgeExpressConfigSchema } from '../HttpBridge.ts'
+
+/**
+ * @group module
+ * @group bridge
+ */
+
+describe('HttpBridgeExpress', () => {
+  const baseUrl = `${process.env.API_DOMAIN ?? 'http://localhost:8080'}`
+
+  console.log(`HttpBridgeExpress:baseUrl ${baseUrl}`)
+  it('Discover', async () => {
+    const nodeUrl = `${baseUrl}/`
+    const memNode = await MemoryNode.create({ account: 'random', config: { name: 'MemoryNode', schema: NodeConfigSchema } })
+
+    const bridge = await HttpBridgeExpress.create({
+      account: 'random',
+      config: {
+        discoverRoots: 'start', name: 'HttpBridgeExpress', nodeUrl, schema: HttpBridgeExpressConfigSchema, security: { allowAnonymous: true },
+      },
+    })
+
+    await memNode.register(bridge)
+    await memNode.attach(bridge.address, true)
+
+    const publicNode = await bridge.resolve<NodeInstance>('XYOPublic')
+    expect(publicNode).toBeDefined()
+
+    if (publicNode) {
+      console.log(`publicNode[${publicNode.address}]: ${publicNode.modName}`)
+      const publicNodeModules = await publicNode.resolve('*', { direction: 'down' })
+      expect(publicNodeModules).toBeArray()
+      expect(publicNodeModules.length).toBeGreaterThan(0)
+    }
+
+    const bridgeModules = await bridge.resolve('*', { direction: 'down' })
+    expect(bridgeModules).toBeArray()
+    expect(bridgeModules.length).toBeGreaterThan(0)
+
+    /*
+    const modules = await memNode.resolve('*')
+    expect(modules).toBeArray()
+    expect(modules.length).toBeGreaterThan(20)
+    */
+  })
+})