@dxos/edge-client 0.6.12 → 0.6.13-main.548ca8d

package/src/protocol.ts

@@ -4,10 +4,10 @@
 
 import { invariant } from '@dxos/invariant';
 import { buf, bufWkt } from '@dxos/protocols/buf';
-import { type Message, MessageSchema, type Peer as PeerProto } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { type Message, MessageSchema, type PeerSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 import { bufferToArray } from '@dxos/util';
 
-export type PeerData = Partial<PeerProto>;
+export type PeerData = buf.MessageInitShape<typeof PeerSchema>;
 
 export const getTypename = (typeName: string) => `type.googleapis.com/${typeName}`;
 

package/src/testing/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './test-utils';

package/src/testing/test-utils.ts

@@ -0,0 +1,114 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import WebSocket from 'isomorphic-ws';
+
+import { Trigger } from '@dxos/async';
+import { log } from '@dxos/log';
+import { buf } from '@dxos/protocols/buf';
+import { MessageSchema, TextMessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+
+import { protocol } from '../defs';
+import { toUint8Array } from '../protocol';
+
+export const DEFAULT_PORT = 8080;
+
+type TestEdgeWsServerParams = {
+  admitConnection?: Trigger;
+  payloadDecoder?: (payload: Uint8Array) => any;
+  messageHandler?: (payload: any) => Promise<Uint8Array | undefined>;
+};
+
+export const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestEdgeWsServerParams) => {
+  const server = new WebSocket.Server({ port, verifyClient: createConnectionDelayHandler(params) });
+
+  let connection: WebSocket | undefined;
+
+  const messageSink: any[] = [];
+  const closeTrigger = new Trigger();
+  const sendResponseMessage = createResponseSender(() => connection!);
+
+  server.on('connection', (ws) => {
+    connection = ws;
+    ws.on('error', (err) => log.catch(err));
+    ws.on('message', async (data) => {
+      if (String(data) === '__ping__') {
+        ws.send('__pong__');
+        return;
+      }
+      const { request, requestPayload } = await decodeRequest(params, data);
+      if (params?.messageHandler) {
+        const responsePayload = await params.messageHandler(requestPayload);
+        if (responsePayload && connection) {
+          sendResponseMessage(request, responsePayload);
+        }
+      }
+      log('message', { payload: requestPayload });
+      messageSink.push(requestPayload);
+    });
+
+    ws.on('close', () => {
+      connection = undefined;
+      closeTrigger.wake();
+    });
+  });
+
+  return {
+    server,
+    messageSink,
+    endpoint: `ws://localhost:${port}`,
+    cleanup: () => server.close(),
+    currentConnection: () => connection,
+    sendResponseMessage,
+    sendMessage: (msg: Message) => {
+      connection!.send(buf.toBinary(MessageSchema, msg));
+    },
+    closeConnection: () => {
+      closeTrigger.reset();
+      connection!.close(1011);
+      return closeTrigger.wait();
+    },
+  };
+};
+
+const createConnectionDelayHandler = (params: TestEdgeWsServerParams | undefined) => {
+  return (_: any, callback: (admit: boolean) => void) => {
+    if (params?.admitConnection) {
+      log('delaying edge connection admission');
+      void params.admitConnection.wait().then(() => {
+        callback(true);
+        log('edge connection admitted');
+      });
+    } else {
+      callback(true);
+    }
+  };
+};
+
+const createResponseSender = (connection: () => WebSocket) => {
+  return (request: Message, responsePayload: Uint8Array) => {
+    const recipient = request.source!;
+    connection().send(
+      buf.toBinary(
+        MessageSchema,
+        buf.create(MessageSchema, {
+          source: {
+            identityKey: recipient.identityKey,
+            peerKey: recipient.peerKey,
+          },
+          serviceId: request.serviceId!,
+          payload: { value: responsePayload },
+        }),
+      ),
+    );
+  };
+};
+
+const decodeRequest = async (params: TestEdgeWsServerParams | undefined, data: any) => {
+  const request = buf.fromBinary(MessageSchema, await toUint8Array(data));
+  const requestPayload = params?.payloadDecoder
+    ? params.payloadDecoder(request.payload!.value!)
+    : protocol.getPayload(request, TextMessageSchema);
+  return { request, requestPayload };
+};

package/src/utils.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const getEdgeUrlWithProtocol = (baseUrl: string, protocol: 'http' | 'ws') => {
+  const isSecure = baseUrl.startsWith('https') || baseUrl.startsWith('wss');
+  const url = new URL(baseUrl);
+  url.protocol = protocol + (isSecure ? 's' : '');
+  return url.toString();
+};

package/src/websocket.test.ts

@@ -2,17 +2,18 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect } from 'chai';
 import WebSocket from 'isomorphic-ws';
+import { describe, expect, test, onTestFinished } from 'vitest';
 
 import { Trigger, TriggerState } from '@dxos/async';
-import { describe, test } from '@dxos/test';
 
-import { createTestWsServer } from './test-utils';
+import { createTestEdgeWsServer } from './testing';
 
 describe('WebSocket', () => {
   test('swap `onclose` handler ', async () => {
-    const { endpoint } = await createTestWsServer();
+    const { endpoint, cleanup } = await createTestEdgeWsServer(8003);
+    onTestFinished(cleanup);
+
     const ws = new WebSocket(endpoint);
     const opened = new Trigger();
     ws.onopen = () => {

package/dist/types/src/test-utils.d.ts

@@ -1,11 +0,0 @@
-import WebSocket from 'isomorphic-ws';
-export declare const DEFAULT_PORT = 8080;
-export declare const createTestWsServer: (port?: number) => Promise<{
-    server: WebSocket.Server;
-    /**
-     * Close the server connection.
-     */
-    error: () => Promise<void>;
-    endpoint: string;
-}>;
-//# sourceMappingURL=test-utils.d.ts.map

package/dist/types/src/test-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../../src/test-utils.ts"],"names":[],"mappings":"AAIA,OAAO,SAAS,MAAM,eAAe,CAAC;AAWtC,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,eAAO,MAAM,kBAAkB;;IAsB3B;;OAEG;;;EAON,CAAC"}

package/src/test-utils.ts

@@ -1,49 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import WebSocket from 'isomorphic-ws';
-
-import { Trigger } from '@dxos/async';
-import { log } from '@dxos/log';
-import { buf } from '@dxos/protocols/buf';
-import { MessageSchema, TextMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
-import { afterTest } from '@dxos/test';
-
-import { protocol } from './defs';
-import { toUint8Array } from './protocol';
-
-export const DEFAULT_PORT = 8080;
-
-export const createTestWsServer = async (port = DEFAULT_PORT) => {
-  const server = new WebSocket.Server({ port });
-  let connection: WebSocket;
-  const closeTrigger = new Trigger();
-  server.on('connection', (ws) => {
-    connection = ws;
-    ws.on('error', (err) => log.catch(err));
-    ws.on('message', async (data) => {
-      if (String(data) === '__ping__') {
-        ws.send('__pong__');
-        return;
-      }
-      log('message', {
-        payload: protocol.getPayload(buf.fromBinary(MessageSchema, await toUint8Array(data)), TextMessageSchema),
-      });
-    });
-    ws.on('close', () => closeTrigger.wake());
-  });
-
-  afterTest(() => server.close());
-  return {
-    server,
-    /**
-     * Close the server connection.
-     */
-    error: async () => {
-      connection.close(1011);
-      await closeTrigger.wait();
-    },
-    endpoint: `ws://localhost:${port}`,
-  };
-};