@rest-vir/run-service 1.4.0 → 1.5.1

package/dist/handle-request/handle-cors.js

@@ -63,7 +63,11 @@ function buildStandardCorsHeaders(matchedOrigin, customHeaders) {
         };
     }
 }
-const accessControlMaxAgeValue = String(convertDuration({ hours: 1 }, { seconds: true }).seconds);
+const accessControlMaxAgeValue = String(convertDuration({
+    hours: 1,
+}, {
+    seconds: true,
+}).seconds);
 const contentLengthHeaders = {
     /**
      * Safari (and potentially other browsers) need content-length 0 for 204 or it will hang waiting

package/dist/handle-request/handle-endpoint.js

@@ -37,7 +37,7 @@ export async function handleEndpointRequest({ endpoint, request, response, attac
         if (!endpointResult.statusCode) {
             throw new RestVirHandlerError(endpoint, 'Missing response status code.');
         }
-        if (isErrorHttpStatus(endpointResult.statusCode)) {
+        else if (isErrorHttpStatus(endpointResult.statusCode)) {
             endpoint.service.logger.error(new RestVirHandlerError(endpoint, `Endpoint implementation returned error status: ${endpointResult.statusCode}`, endpointResult.statusCode));
             return {
                 statusCode: endpointResult.statusCode,
@@ -50,7 +50,9 @@ export async function handleEndpointRequest({ endpoint, request, response, attac
                 throw new RestVirHandlerError(endpoint, 'Got response data but none was expected.');
             }
             if (!endpoint.bypassResponseValidation) {
-                assertValidShape(endpointResult.responseData, endpoint.responseDataShape, { allowExtraKeys: true }, 'invalid response data');
+                assertValidShape(endpointResult.responseData, endpoint.responseDataShape, {
+                    allowExtraKeys: true,
+                }, 'invalid response data');
             }
             return {
                 headers: {

package/dist/handle-request/handle-route.js

@@ -73,7 +73,10 @@ export async function handleRoute({ webSocket, request, response, route, attachI
     catch (error) {
         if (error instanceof RejectRequestError) {
             assert.isDefined(response, 'no response object');
-            await handleHandlerOutput({ statusCode: error.httpStatus, body: error.responseErrorMessage }, response);
+            await handleHandlerOutput({
+                statusCode: error.httpStatus,
+                body: error.responseErrorMessage,
+            }, response);
             return;
         }
         route.service.logger.error(ensureError(error));

package/dist/handle-request/handle-search-params.js

@@ -15,7 +15,9 @@ export function handleSearchParams({ request, route, }) {
     const shape = route.searchParamsShape;
     const validationError = shape
         ? wrapInTry(() => {
-            assertValidShape(searchParams, shape, { allowExtraKeys: true });
+            assertValidShape(searchParams, shape, {
+                allowExtraKeys: true,
+            });
             return undefined;
         })
         : undefined;

package/dist/handle-request/handle-web-socket.js

@@ -15,6 +15,19 @@ export async function handleWebSocketRequest({ attachId, request, implementedWeb
     const restVirContext = request.restVirContext?.[attachId];
     assert.isDefined(restVirContext, 'restVirContext is not defined');
     const webSocket = overwriteWebSocketMethods(implementedWebSocket, wsWebSocket, WebSocketLocation.OnHost);
+    /**
+     * `Duplexify`-based sockets (used by `@fastify/websocket`'s `injectWS` for testing) don't emit
+     * `'close'` after `end()` like real TCP sockets do. The `ws` library relies on the socket
+     * `'close'` event to fire `emitClose()` and complete the close handshake. Destroying the socket
+     * when it finishes writing triggers `'close'` promptly. For real TCP sockets this is
+     * effectively a no-op since they close naturally after the FIN handshake.
+     */
+    const rawSocket = wsWebSocket._socket;
+    rawSocket?.on('finish', () => {
+        if (!rawSocket.destroyed) {
+            rawSocket.destroy();
+        }
+    });
     const webSocketCallbackParams = {
         context: restVirContext.context,
         headers: request.headers,
@@ -40,7 +53,9 @@ export async function handleWebSocketRequest({ attachId, request, implementedWeb
                 const stringRawMessage = String(rawMessage);
                 message = parseJsonWithUndefined(stringRawMessage);
                 if (implementedWebSocket.messageFromClientShape) {
-                    assertValidShape(message, implementedWebSocket.messageFromClientShape, { allowExtraKeys: true }, 'Invalid message send shape.');
+                    assertValidShape(message, implementedWebSocket.messageFromClientShape, {
+                        allowExtraKeys: true,
+                    }, 'Invalid message send shape.');
                 }
                 else if (message) {
                     throw new Error(`Did not expect any data from the client but got ${stringify(message)}.`);

package/dist/handle-request/pre-handler.js

@@ -74,7 +74,10 @@ export async function preHandler({ request, response, service, server, attachId,
         };
     }
     attachedRestVirContext.requestData = requestData;
-    const searchParams = handleSearchParams({ request, route });
+    const searchParams = handleSearchParams({
+        request,
+        route,
+    });
     if (!('data' in searchParams)) {
         return handleHandlerOutputWithoutSending(searchParams, response);
     }

package/dist/start-service/start-service.js

@@ -80,7 +80,10 @@ async function startServer(service, { host, port }, fastifyPlugins) {
     await attachService(server, service, {
         throwErrorsForExternalHandling: false,
     });
-    await server.listen({ port, host });
+    await server.listen({
+        port,
+        host,
+    });
     return {
         host,
         port,

package/dist/test/test-service.js

@@ -188,6 +188,27 @@ export async function testExistingServer(server, service, options = {}) {
                     }
                     : {}))
                 : new WebSocket(webSocketUrl, protocols);
+            if (webSocketOrigin == undefined) {
+                /**
+                 * `injectWS` creates a `ws` WebSocket with `_closeTimeout = undefined`.
+                 * `setTimeout(fn, undefined)` fires immediately (0ms), which destroys the
+                 * socket before the close frame can be sent, preventing the server-side close
+                 * event from firing. Set a reasonable fallback timeout.
+                 *
+                 * Additionally, `injectWS` uses `Duplexify` streams which don't emit `'close'`
+                 * after `end()` like real TCP sockets do. The `ws` library relies on the socket
+                 * `'close'` event to complete the close handshake. Destroying the socket when
+                 * it finishes writing triggers `'close'` promptly instead of waiting for the
+                 * full close timeout.
+                 */
+                const wsInternal = webSocket;
+                wsInternal._closeTimeout = 5000;
+                wsInternal._socket?.on('finish', () => {
+                    if (!wsInternal._socket?.destroyed) {
+                        wsInternal._socket?.destroy();
+                    }
+                });
+            }
             const finalized = await finalizeWebSocket(webSocketDefinition, webSocket, listeners, WebSocketLocation.OnClient);
             if (webSocketOrigin == undefined) {
                 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/run-service",
-    "version": "1.4.0",
+    "version": "1.5.1",
     "description": "Run a service defined by @rest-vir/define-service and implemented by @rest-vir/implement-service.",
     "keywords": [
         "rest",
@@ -39,31 +39,31 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.55.0",
-        "@augment-vir/common": "^31.55.0",
-        "@augment-vir/node": "^31.55.0",
+        "@augment-vir/assert": "^31.68.1",
+        "@augment-vir/common": "^31.68.1",
+        "@augment-vir/node": "^31.68.1",
         "@fastify/compress": "^8.3.1",
         "@fastify/websocket": "^11.2.0",
-        "@rest-vir/define-service": "^1.4.0",
-        "@rest-vir/implement-service": "^1.4.0",
+        "@rest-vir/define-service": "^1.5.1",
+        "@rest-vir/implement-service": "^1.5.1",
         "cluster-vir": "^1.0.1",
-        "date-vir": "^8.1.0",
-        "fastify": "^5.6.2",
+        "date-vir": "^8.2.1",
+        "fastify": "^5.8.2",
         "light-my-request": "^6.6.0",
         "portfinder": "^1.0.38",
-        "type-fest": "^5.3.1",
+        "type-fest": "^5.4.4",
         "url-vir": "^2.1.7"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.55.0",
-        "@fastify/multipart": "^9.3.0",
+        "@augment-vir/test": "^31.68.1",
+        "@fastify/multipart": "^9.4.0",
         "@types/connect": "^3.4.38",
-        "@types/node": "^25.0.3",
+        "@types/node": "^25.3.0",
         "@types/ws": "^8.18.1",
-        "c8": "^10.1.3",
+        "c8": "^11.0.0",
         "istanbul-smart-text-reporter": "^1.1.5",
         "markdown-code-example-inserter": "^3.0.3",
-        "object-shape-tester": "^6.10.1"
+        "object-shape-tester": "^6.11.0"
     },
     "peerDependencies": {
         "@augment-vir/test": ">=30",