@xyo-network/bridge-websocket 2.94.5 → 2.94.7

package/src/ModuleResolver.ts

@@ -0,0 +1,76 @@
+import { assertEx } from '@xylabs/assert'
+import { Address, isAddress } from '@xylabs/hex'
+import { AbstractBridgeModuleResolver, BridgeModuleResolverOptions, 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 } from '@xyo-network/module-model'
+
+import { WebsocketModuleProxy, WebsocketModuleProxyParams } from './ModuleProxy'
+
+export interface WebsocketBridgeModuleResolverOptions extends BridgeModuleResolverOptions {
+  url: string
+}
+
+export class WebsocketBridgeModuleResolver<
+  T extends WebsocketBridgeModuleResolverOptions = WebsocketBridgeModuleResolverOptions,
+> extends AbstractBridgeModuleResolver<T> {
+  moduleUrl(address: Address) {
+    return new URL(address, this.options.url)
+  }
+
+  override async resolveHandler<T extends ModuleInstance = ModuleInstance>(
+    id: ModuleIdentifier,
+    options?: ModuleFilterOptions<T>,
+  ): Promise<T | T[] | undefined> {
+    const parentResult = await super.resolveHandler(id, options)
+    if (parentResult) {
+      return parentResult
+    }
+    if (id === '*') {
+      return []
+    }
+    const idParts = id.split(':')
+    const firstPart = assertEx(idParts.shift(), () => 'Missing firstPart')
+    const moduleAddress = firstPart as Address
+    assertEx(isAddress(firstPart), () => `Invalid module address: ${firstPart}`)
+    const remainderParts = idParts.join(':')
+    const params: WebsocketModuleProxyParams = {
+      account: Account.randomSync(),
+      config: { schema: ModuleConfigSchema },
+      host: this,
+      moduleAddress,
+      moduleUrl: this.moduleUrl(moduleAddress).href,
+    }
+
+    //console.log(`creating WebsocketProxy [${moduleAddress}] ${id}`)
+
+    const proxy = new WebsocketModuleProxy<T, WebsocketModuleProxyParams>(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 as = assertEx(asModuleInstance<T>(wrapped, {}), () => `Failed to asModuleInstance [${id}]`)
+    proxy.upResolver.add(as)
+    proxy.downResolver.add(as)
+
+    if (remainderParts.length > 0) {
+      const result = await wrapped.resolve<T>(remainderParts, options)
+      return result
+    }
+
+    //console.log(`resolved: ${proxy.address} [${wrapped.constructor.name}] [${as.constructor.name}]`)
+    return as
+  }
+}

package/src/index.ts

@@ -1 +1,2 @@
-export const TODO = true
+export * from './Bridge'
+export * from './Config'

package/src/spec/socketServer.ts

@@ -0,0 +1,68 @@
+import { io as Client, Socket } from 'socket.io-client'
+
+import { BridgeCommands, createServer } from '../socketServer'
+
+/**
+ * @group module
+ * @group bridge
+ */
+describe('WebsocketBridge', () => {
+  let ioServer: { start: () => void; stop: () => void }
+  let moduleClientA: Socket
+  const port = 3001
+  const serverUrl = `http://localhost:${port}`
+  const moduleAddressA = 'f4f4fa193a3b785bcf3f9902d031d49f1cf01a11'
+  const moduleAddressB = '0d8cf1ea18281a34c166624ff9d4e5a473d05ae5'
+
+  beforeAll((done) => {
+    ioServer = createServer(port)
+    ioServer.start()
+    done()
+  })
+
+  afterAll((done) => {
+    ioServer.stop()
+    done()
+  })
+
+  beforeEach((done) => {
+    moduleClientA = Client(serverUrl, {
+      forceNew: true,
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 0,
+      transports: ['websocket'],
+    })
+    moduleClientA.on('connect', () => {
+      done()
+    })
+  })
+
+  afterEach((done) => {
+    if (moduleClientA.connected) {
+      moduleClientA.disconnect()
+    }
+    done()
+  })
+
+  test('should communicate between modules', (done) => {
+    const moduleClientB = Client(serverUrl, {
+      forceNew: true,
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 0,
+      transports: ['websocket'],
+    })
+    const query = `Hello from ${moduleAddressB}`
+    moduleClientB.on('connect', () => {
+      moduleClientB.emit(BridgeCommands.bridge, moduleAddressA)
+      moduleClientA.emit(BridgeCommands.sendMessage, { address: moduleAddressA, query })
+    })
+    moduleClientB.on('message', (received) => {
+      expect(received).toBe(query)
+      moduleClientB.disconnect()
+      done()
+    })
+    moduleClientA.emit(BridgeCommands.bridge, moduleAddressA)
+  })
+})