@rest-vir/define-service 0.1.0 → 0.3.0

package/dist/frontend-connect/mock-client-web-socket.d.ts

@@ -78,7 +78,7 @@ export declare function createMockClientWebSocketConstructor<const WebSocketToCo
  * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
  */
 export type MockClientWebSocketListeners = Partial<{
-    [EventName in keyof CommonWebSocketEventMap]: Set<(event: CommonWebSocketEventMap[EventName]) => void>;
+    [EventName in keyof CommonWebSocketEventMap]: Set<(event: CommonWebSocketEventMap[EventName]) => MaybePromise<void>>;
 }>;
 /**
  * A mock WebSocket constructor for connections from the client side. This can be passed to
@@ -165,14 +165,14 @@ export declare class MockClientWebSocket<const WebSocketToConnect extends WebSoc
      *
      * @see https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener
      */
-    addEventListener<const EventName extends keyof CommonWebSocketEventMap>(eventName: EventName, listener: (event: CommonWebSocketEventMap[EventName]) => void): void;
+    addEventListener<const EventName extends keyof CommonWebSocketEventMap>(eventName: EventName, listener: (event: CommonWebSocketEventMap[EventName]) => MaybePromise<void>): void;
     /**
      * Implements and mocks the standard `WebSocket.removeEventListener` property but with message
      * type safety.
      *
      * @see https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener
      */
-    removeEventListener<const EventName extends keyof CommonWebSocketEventMap>(eventName: EventName, listener: (event: CommonWebSocketEventMap[EventName]) => void): void;
+    removeEventListener<const EventName extends keyof CommonWebSocketEventMap>(eventName: EventName, listener: (event: CommonWebSocketEventMap[EventName]) => MaybePromise<void>): void;
     /**
      * Implements and mocks the standard `WebSocket.send` property but with message type safety.
      *

package/dist/frontend-connect/mock-client-web-socket.js

@@ -139,11 +139,13 @@ export class MockClientWebSocket {
      * methods instead (which appropriately dispatch their events).
      */
     dispatchEvent(eventName, event) {
-        this.listeners[eventName]?.forEach((listener) => listener({
-            ...event,
-            target: this,
-            type: eventName,
-        }));
+        this.listeners[eventName]?.forEach((listener) => {
+            void listener({
+                ...event,
+                target: this,
+                type: eventName,
+            });
+        });
     }
     /**
      * Implements and mocks the standard `WebSocket.addEventListener` property but with message type
@@ -187,7 +189,7 @@ export class MockClientWebSocket {
             return;
         }
         this.dispatchEvent('message', {
-            data,
+            data: JSON.stringify(data),
         });
         void this.sendCallback?.({
             messageData: data,

package/dist/web-socket/overwrite-web-socket-methods.d.ts

@@ -69,6 +69,13 @@ export type SendAndWaitForReplyParams<Location extends WebSocketLocation, WebSoc
      * @default {seconds: 10}
      */
     timeout?: Readonly<AnyDuration> | undefined;
+    /**
+     * An optional function to check if the current reply is the one you were waiting for.
+     *
+     * If this is set, `sendAndWaitForReply` will wait until a reply is received that matches this
+     * condition. If this not set, the first reply is used.
+     */
+    replyCheck?: (messageFromHost: WebSocketToConnect extends NoParam ? any : Exclude<WebSocketToConnect, NoParam>['MessageFromHostType']) => MaybePromise<boolean>;
 };
 /**
  * Collapsed version of {@link SendAndWaitForReplyParams} for the `sendAndWaitForReply` method that
@@ -95,6 +102,11 @@ export type OverwriteWebSocketMethods<WebSocketClass extends CommonWebSocket, Lo
     MessageFromHostType: true;
     SearchParamsType: true;
 }>> | NoParam = NoParam> = Overwrite<WebSocketClass, {
+    /**
+     * Closes the WebSocket and waits it to actually close (so that you _know_ it's been closed
+     * once this resolves).
+     */
+    close(): Promise<void>;
     /**
      * Adds an event listener that's wrapped in assertions to verify that message events have
      * the expected contents.

package/dist/web-socket/overwrite-web-socket-methods.js

@@ -1,5 +1,5 @@
 import { waitUntil } from '@augment-vir/assert';
-import { DeferredPromise, ensureErrorAndPrependMessage, getOrSet, stringify, } from '@augment-vir/common';
+import { callAsynchronously, DeferredPromise, ensureErrorAndPrependMessage, getOrSet, stringify, wrapInTry, } from '@augment-vir/common';
 import { convertDuration } from 'date-vir';
 import { assertValidShape } from 'object-shape-tester';
 import { parseJsonWithUndefined } from '../augments/json.js';
@@ -44,12 +44,31 @@ export function getOppositeWebSocketLocation(originalWebSocketLocation) {
  */
 export function overwriteWebSocketMethods(webSocketDefinition, rawWebSocket, webSocketLocation) {
     const originalSend = rawWebSocket.send;
+    const originalClose = rawWebSocket.close;
     const originalAddEventListener = rawWebSocket.addEventListener;
     const originalRemoveEventListener = rawWebSocket.removeEventListener;
     const webSocket = rawWebSocket;
+    const deferredClosePromise = new DeferredPromise();
+    webSocket.addEventListener('close', () => {
+        /**
+         * Call this asynchronously so the other `close` event listeners get fired before this
+         * resolves.
+         */
+        void callAsynchronously(() => {
+            deferredClosePromise.resolve();
+        });
+    });
     const originalListenerMap = {};
     Object.assign(webSocket, {
         originalListenerMap,
+        async close() {
+            originalClose.call(webSocket);
+            /**
+             * Closing takes a _long time_ for some reason, so we want to wait until it's actually
+             * done before proceeding with other operations.
+             */
+            await deferredClosePromise.promise;
+        },
         addEventListener(eventName, listener) {
             function newListener(event) {
                 const baseParams = {
@@ -84,11 +103,16 @@ export function overwriteWebSocketMethods(webSocketDefinition, rawWebSocket, web
                 originalRemoveEventListener.call(webSocket, eventName, existing);
             }
         },
-        async sendAndWaitForReply({ message, timeout = { seconds: 10 }, } = {}) {
+        async sendAndWaitForReply({ message, timeout = { seconds: 10 }, replyCheck, } = {}) {
             const deferredReply = new DeferredPromise();
-            function listener({ message, }) {
+            async function listener({ message, }) {
                 if (!deferredReply.isSettled) {
-                    deferredReply.resolve(message);
+                    const matchesChecker = replyCheck
+                        ? (await wrapInTry(() => replyCheck(message))) === true
+                        : true;
+                    if (matchesChecker) {
+                        deferredReply.resolve(message);
+                    }
                 }
             }
             setTimeout(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/define-service",
-    "version": "0.1.0",
+    "version": "0.3.0",
     "description": "Define an connect to a declarative and type safe REST and WebSocket service.",
     "keywords": [
         "rest",