@rest-vir/run-service 0.19.0 → 0.19.2

package/dist/handle-request/endpoint-handler.d.ts

@@ -65,6 +65,15 @@ export type EndpointHandlerParams = {
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
 export type EndpointHandler = (params: Readonly<EndpointHandlerParams>) => MaybePromise<HandledOutput>;
+/**
+ * Handle the output of a handler without sending the response. Similar to
+ * {@link handleHandlerOutput} but this one does not send the response.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/run-service
+ * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
+ */
+export declare function handleHandlerOutputWithoutSending(result: Readonly<HandledOutput>, response: ServerResponse): undefined | HandledOutput;
 /**
  * Handle the output of a handler. Setting headers, sending the response, etc.
  *
@@ -72,4 +81,4 @@ export type EndpointHandler = (params: Readonly<EndpointHandlerParams>) => Maybe
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export declare function handleHandlerResult(result: Readonly<HandledOutput>, response: ServerResponse): undefined | FastifyReply;
+export declare function handleHandlerOutput(result: Readonly<HandledOutput>, response: ServerResponse): undefined | FastifyReply;

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

@@ -1,5 +1,26 @@
 /* node:coverage disable: this file is just types */
 import { setResponseHeaders } from '../util/headers.js';
+/**
+ * Handle the output of a handler without sending the response. Similar to
+ * {@link handleHandlerOutput} but this one does not send the response.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/run-service
+ * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
+ */
+export function handleHandlerOutputWithoutSending(result, response) {
+    if (result?.headers) {
+        setResponseHeaders(response, result.headers);
+    }
+    if (result?.statusCode) {
+        response.statusCode = result.statusCode;
+        return {
+            body: result.body,
+            statusCode: result.statusCode,
+        };
+    }
+    return undefined;
+}
 /**
  * Handle the output of a handler. Setting headers, sending the response, etc.
  *
@@ -7,7 +28,7 @@ import { setResponseHeaders } from '../util/headers.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export function handleHandlerResult(result, response) {
+export function handleHandlerOutput(result, response) {
     if (result?.headers) {
         setResponseHeaders(response, result.headers);
     }

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

@@ -11,6 +11,7 @@ import { assertValidShape } from 'object-shape-tester';
  */
 export async function handleEndpointRequest({ endpoint, request, response, attachId, server, }) {
     try {
+        // by this point in the request lifecycle, we know that these properties have been set.
         const restVirContext = request.restVirContext?.[attachId];
         assert.isDefined(restVirContext, 'restVirContext is not defined');
         const context = restVirContext.context;

package/dist/handle-request/handle-route.d.ts

@@ -1,4 +1,5 @@
-import { type ImplementedEndpoint, type ImplementedWebSocket, type RunningServerInfo, type ServerRequest, type ServerResponse } from '@rest-vir/implement-service';
+import { type SelectFrom } from '@augment-vir/common';
+import { type GenericServiceImplementation, type ImplementedEndpoint, type ImplementedWebSocket, type PostHook, type RunningServerInfo, type ServerRequest, type ServerResponse } from '@rest-vir/implement-service';
 import { type WebSocket as WsWebSocket } from 'ws';
 import { type HandleRouteOptions } from './endpoint-handler.js';
 /**
@@ -8,8 +9,20 @@ import { type HandleRouteOptions } from './endpoint-handler.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export declare function handleRoute(
-/** Endpoint requests won't have a `WebSocket`. */
-webSocket: WsWebSocket | undefined, request: ServerRequest, 
-/** `WebSocket` requests won't have a response. */
-response: ServerResponse | undefined, route: Readonly<ImplementedEndpoint | ImplementedWebSocket>, attachId: string, server: Readonly<RunningServerInfo>, options?: Readonly<Pick<HandleRouteOptions, 'throwErrorsForExternalHandling'>>): Promise<void>;
+export declare function handleRoute({ webSocket, request, response, route, attachId, server, options, postHook, service, }: {
+    /** Endpoint requests won't have a `WebSocket`. */ webSocket: WsWebSocket | undefined;
+    request: ServerRequest /** `WebSocket` requests won't have a response. */;
+    response: ServerResponse | undefined;
+    route: Readonly<ImplementedEndpoint | ImplementedWebSocket>;
+    attachId: string;
+    server: Readonly<RunningServerInfo>;
+    options: Readonly<Pick<HandleRouteOptions, 'throwErrorsForExternalHandling'>>;
+    postHook: PostHook | undefined;
+    service: Readonly<SelectFrom<GenericServiceImplementation, {
+        webSockets: true;
+        endpoints: true;
+        serviceName: true;
+        serviceOrigin: true;
+        requiredClientOrigin: true;
+    }>>;
+}): Promise<void>;

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

@@ -2,9 +2,10 @@ import { assert, check } from '@augment-vir/assert';
 import { ensureError, HttpStatus } from '@augment-vir/common';
 import { RestVirHandlerError, } from '@rest-vir/implement-service';
 import cluster from 'node:cluster';
-import { handleHandlerResult } from './endpoint-handler.js';
+import { handleHandlerOutput, handleHandlerOutputWithoutSending, } from './endpoint-handler.js';
 import { handleEndpointRequest } from './handle-endpoint.js';
 import { handleWebSocketRequest } from './handle-web-socket.js';
+import { runPostHook } from './run-post-hook.js';
 /**
  * Handles a WebSocket or Endpoint request.
  *
@@ -12,11 +13,7 @@ import { handleWebSocketRequest } from './handle-web-socket.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export async function handleRoute(
-/** Endpoint requests won't have a `WebSocket`. */
-webSocket, request, 
-/** `WebSocket` requests won't have a response. */
-response, route, attachId, server, options = {}) {
+export async function handleRoute({ webSocket, request, response, route, attachId, server, options = {}, postHook, service, }) {
     try {
         const workerPid = cluster.isPrimary ? '' : process.pid;
         const webSocketMarker = route.isWebSocket ? '(ws)' : '';
@@ -36,9 +33,28 @@ response, route, attachId, server, options = {}) {
                 attachId,
                 server,
             });
-            const sentResponse = handleHandlerResult(result, response);
-            if (sentResponse) {
-                return sentResponse;
+            const endpointResult = handleHandlerOutputWithoutSending(result, response);
+            const postHookResult = (postHook &&
+                endpointResult?.statusCode &&
+                (await runPostHook({
+                    attachId,
+                    originalBody: endpointResult.body,
+                    originalStatus: endpointResult.statusCode,
+                    postHook,
+                    request,
+                    response,
+                    server,
+                    service,
+                }))) ||
+                endpointResult;
+            if (postHookResult) {
+                if (postHookResult.body == undefined) {
+                    postHookResult.headers = {
+                        ...postHookResult.headers,
+                        'content-type': undefined,
+                    };
+                }
+                return handleHandlerOutput(postHookResult, response);
             }
         }
         else if (route.isWebSocket) {

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

@@ -11,6 +11,7 @@ import { assertValidShape } from 'object-shape-tester';
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
 export async function handleWebSocketRequest({ attachId, request, implementedWebSocket, webSocket: wsWebSocket, server, }) {
+    // by this point in the request lifecycle, we know that these properties have been set.
     const restVirContext = request.restVirContext?.[attachId];
     assert.isDefined(restVirContext, 'restVirContext is not defined');
     const webSocket = overwriteWebSocketMethods(implementedWebSocket, wsWebSocket, WebSocketLocation.OnHost);

package/dist/handle-request/pre-handler.d.ts

@@ -1,6 +1,6 @@
 import { type SelectFrom } from '@augment-vir/common';
 import { type GenericServiceImplementation, type RunningServerInfo, type ServerRequest, type ServerResponse } from '@rest-vir/implement-service';
-import { type FastifyReply } from 'fastify';
+import { type HandledOutput } from './endpoint-handler.js';
 /**
  * Handles a request before it gets to the actual route handlers.
  *
@@ -8,12 +8,18 @@ import { type FastifyReply } from 'fastify';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export declare function preHandler(request: ServerRequest, response: ServerResponse, service: Readonly<SelectFrom<GenericServiceImplementation, {
-    webSockets: true;
-    endpoints: true;
-    serviceName: true;
-    createContext: true;
-    serviceOrigin: true;
-    requiredClientOrigin: true;
-    logger: true;
-}>>, server: Readonly<RunningServerInfo>, attachId: string): Promise<FastifyReply | undefined>;
+export declare function preHandler({ request, response, service, server, attachId, }: {
+    request: ServerRequest;
+    response: ServerResponse;
+    service: Readonly<SelectFrom<GenericServiceImplementation, {
+        webSockets: true;
+        endpoints: true;
+        serviceName: true;
+        createContext: true;
+        serviceOrigin: true;
+        requiredClientOrigin: true;
+        logger: true;
+    }>>;
+    server: Readonly<RunningServerInfo>;
+    attachId: string;
+}): Promise<Readonly<HandledOutput>>;

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

@@ -1,9 +1,9 @@
 import { assertWrap } from '@augment-vir/assert';
-import { ensureErrorAndPrependMessage, extractErrorMessage, HttpStatus, stringify, wrapInTry, } from '@augment-vir/common';
+import { ensureErrorAndPrependMessage, extractErrorMessage, getOrSet, HttpStatus, stringify, wrapInTry, } from '@augment-vir/common';
 import { isFormDataShape, matchUrlToService, restVirServiceNameHeader, } from '@rest-vir/define-service';
 import { HttpMethod, RestVirHandlerError, } from '@rest-vir/implement-service';
 import { assertValidShape, isValidShape } from 'object-shape-tester';
-import { handleHandlerResult } from './endpoint-handler.js';
+import { handleHandlerOutputWithoutSending } from './endpoint-handler.js';
 import { handleCors } from './handle-cors.js';
 import { handleRequestMethod } from './handle-request-method.js';
 import { handleSearchParams } from './handle-search-params.js';
@@ -14,7 +14,13 @@ import { handleSearchParams } from './handle-search-params.js';
  * @category Package : @rest-vir/run-service
  * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
  */
-export async function preHandler(request, response, service, server, attachId) {
+export async function preHandler({ request, response, service, server, attachId, }) {
+    if (!request.restVirContext) {
+        request.restVirContext = {};
+    }
+    const attachedRestVirContext = getOrSet(request.restVirContext, attachId, () => {
+        return {};
+    });
     response.header(restVirServiceNameHeader, service.serviceName);
     const pathMatch = matchUrlToService(service, request.originalUrl);
     if (!pathMatch) {
@@ -41,15 +47,17 @@ export async function preHandler(request, response, service, server, attachId) {
         : undefined;
     if (protocolShapeError) {
         service.logger.error(new RestVirHandlerError(route, extractErrorMessage(ensureErrorAndPrependMessage(protocolShapeError, `WebSocket protocols rejected (${stringify(protocols)}):`))));
-        response.statusCode = HttpStatus.BadRequest;
-        response.send('Invalid protocols.');
-        return undefined;
+        return {
+            statusCode: HttpStatus.BadRequest,
+            body: 'Invalid protocol.',
+        };
     }
-    const subHandlerResponse = handleHandlerResult(await handleCors({
+    attachedRestVirContext.protocols = protocols;
+    const subHandlerResponse = handleHandlerOutputWithoutSending(await handleCors({
         request,
         route,
     }), response) ||
-        handleHandlerResult(handleRequestMethod({
+        handleHandlerOutputWithoutSending(handleRequestMethod({
             request,
             route,
         }), response);
@@ -59,15 +67,19 @@ export async function preHandler(request, response, service, server, attachId) {
     const requestData = wrapInTry(() => extractRequestData(request.body, request.headers, route));
     if (requestData instanceof Error) {
         service.logger.error(new RestVirHandlerError(route, `Rejected request body from '${request.originalUrl}': ${stringify(requestData)}`));
-        response.statusCode = HttpStatus.BadRequest;
-        response.send('Invalid body.');
-        return undefined;
+        return {
+            statusCode: HttpStatus.BadRequest,
+            body: 'Invalid body.',
+        };
     }
+    attachedRestVirContext.requestData = requestData;
     const searchParams = handleSearchParams({ request, route });
     if (!('data' in searchParams)) {
-        return handleHandlerResult(searchParams, response);
+        return handleHandlerOutputWithoutSending(searchParams, response);
     }
+    attachedRestVirContext.searchParams = searchParams.data;
     const contextParams = {
+        pathParams: request.params,
         method: assertWrap.isEnumValue(request.method.toUpperCase(), HttpMethod),
         request,
         requestData,
@@ -83,21 +95,13 @@ export async function preHandler(request, response, service, server, attachId) {
         const contextOutput = await service.createContext?.(contextParams);
         if (contextOutput?.reject) {
             service.logger.error(new RestVirHandlerError(route, `Context creation rejected: '${request.originalUrl}'`));
-            return handleHandlerResult({
+            return handleHandlerOutputWithoutSending({
                 body: contextOutput.reject.responseErrorMessage,
                 statusCode: contextOutput.reject.statusCode,
                 headers: contextOutput.reject.headers,
             }, response);
         }
-        if (!request.restVirContext) {
-            request.restVirContext = {};
-        }
-        request.restVirContext[attachId] = {
-            context: contextOutput?.context,
-            requestData,
-            protocols,
-            searchParams: searchParams.data,
-        };
+        attachedRestVirContext.context = contextOutput?.context;
         return undefined;
     }
     catch (error) {

package/dist/handle-request/run-post-hook.d.ts

@@ -0,0 +1,17 @@
+import { type HttpStatus, type SelectFrom } from '@augment-vir/common';
+import { type GenericServiceImplementation, type PostHook, type RunningServerInfo } from '@rest-vir/implement-service';
+import { type EndpointHandlerParams, type HandledOutput } from './endpoint-handler.js';
+export declare function runPostHook(this: void, { request, response, attachId, server, postHook, service, originalBody, originalStatus, }: Readonly<Omit<EndpointHandlerParams, 'route'> & {
+    attachId: string;
+    server: Readonly<RunningServerInfo>;
+    postHook: PostHook;
+    originalBody: unknown;
+    originalStatus: HttpStatus;
+    service: Readonly<SelectFrom<GenericServiceImplementation, {
+        webSockets: true;
+        endpoints: true;
+        serviceName: true;
+        serviceOrigin: true;
+        requiredClientOrigin: true;
+    }>>;
+}>): Promise<HandledOutput>;

package/dist/handle-request/run-post-hook.js

@@ -0,0 +1,59 @@
+import { assert, assertWrap } from '@augment-vir/assert';
+import { matchUrlToService } from '@rest-vir/define-service';
+import { HttpMethod, } from '@rest-vir/implement-service';
+export async function runPostHook({ request, response, attachId, server, postHook, service, originalBody, originalStatus, }) {
+    const restVirContext = request.restVirContext?.[attachId];
+    assert.isDefined(restVirContext, 'restVirContext is not defined');
+    const context = restVirContext.context;
+    const requestData = restVirContext.requestData;
+    const searchParams = restVirContext.searchParams;
+    const pathMatch = matchUrlToService(service, request.originalUrl);
+    /* node:coverage ignore next 10 */
+    if (!pathMatch) {
+        return undefined;
+    }
+    const endpointDefinition = pathMatch.endpointPath
+        ? service.endpoints[pathMatch.endpointPath]
+        : undefined;
+    const webSocketDefinition = request.ws && pathMatch.webSocketPath
+        ? service.webSockets[pathMatch.webSocketPath]
+        : undefined;
+    const postHookParams = {
+        pathParams: request.params,
+        method: assertWrap.isEnumValue(request.method.toUpperCase(), HttpMethod),
+        request,
+        requestData,
+        requestHeaders: request.headers,
+        response,
+        service,
+        endpointDefinition,
+        webSocketDefinition,
+        context,
+        searchParams,
+        server,
+        originalResponseData: originalBody,
+        originalStatus,
+    };
+    const result = await postHook(postHookParams);
+    if (result) {
+        return {
+            body: 'responseErrorMessage' in result
+                ? result.responseErrorMessage
+                : 'responseData' in result
+                    ? result.responseData
+                    : originalBody,
+            statusCode: 'statusCode' in result ? result.statusCode : originalStatus,
+            headers: {
+                ...result.headers,
+                ...(result.dataType
+                    ? {
+                        'content-type': result.dataType,
+                    }
+                    : {}),
+            },
+        };
+    }
+    else {
+        return undefined;
+    }
+}

package/dist/start-service/attach-service.d.ts

@@ -3,15 +3,23 @@ import { type BaseSearchParams, type MinimalService } from '@rest-vir/define-ser
 import { type GenericServiceImplementation, type RunningServerInfo } from '@rest-vir/implement-service';
 import { type FastifyInstance } from 'fastify';
 import { type HandleRouteOptions } from '../handle-request/endpoint-handler.js';
+/**
+ * Context attached to each fastify request object.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/run-service
+ * @package [`@rest-vir/run-service`](https://www.npmjs.com/package/@rest-vir/run-service)
+ */
+export type RestVirRequestContext = {
+    context: unknown;
+    requestData: unknown;
+    protocols: string[];
+    searchParams: BaseSearchParams;
+};
 declare module 'fastify' {
     interface FastifyRequest {
         restVirContext: {
-            [AttachId in string]: {
-                context: unknown;
-                requestData: unknown;
-                protocols: string[];
-                searchParams: BaseSearchParams;
-            };
+            [AttachId in string]: Partial<RestVirRequestContext>;
         } | undefined;
     }
 }

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

@@ -1,12 +1,12 @@
-import { assertWrap, check } from '@augment-vir/assert';
-import { ensureError, extractErrorMessage, getEnumValues, getObjectTypedKeys, HttpMethod, HttpStatus, isErrorHttpStatus, randomString, } from '@augment-vir/common';
+import { assert, check } from '@augment-vir/assert';
+import { ensureError, extractErrorMessage, getEnumValues, getObjectTypedKeys, HttpMethod, HttpStatus, randomString, } from '@augment-vir/common';
 import fastifyWs from '@fastify/websocket';
-import { matchUrlToService, } from '@rest-vir/define-service';
 import { RestVirHandlerError, } from '@rest-vir/implement-service';
 import { buildUrl, parseUrl } from 'url-vir';
+import { handleHandlerOutput } from '../handle-request/endpoint-handler.js';
 import { handleRoute } from '../handle-request/handle-route.js';
 import { preHandler } from '../handle-request/pre-handler.js';
-import { setResponseHeaders } from '../util/headers.js';
+import { runPostHook } from '../handle-request/run-post-hook.js';
 const endpointFastifyMethods = getEnumValues(HttpMethod).filter((value) => {
     return (
     /** Fastify doesn't support the CONNECT method. */
@@ -53,94 +53,48 @@ export async function attachService(server, service, options = {}) {
                 },
             });
         }
+        const postHook = service.postHook;
         server.addHook('preValidation', async (request, response) => {
             try {
-                return await preHandler(request, response, service, extractRunningServerInfo(service, server), attachId);
+                const preHandlerResult = await preHandler({
+                    request,
+                    response,
+                    service,
+                    server: extractRunningServerInfo(service, server),
+                    attachId,
+                });
+                if (preHandlerResult?.statusCode && postHook) {
+                    const postHookResult = await runPostHook({
+                        attachId,
+                        originalBody: preHandlerResult.body,
+                        originalStatus: preHandlerResult.statusCode,
+                        postHook,
+                        request,
+                        response,
+                        server: extractRunningServerInfo(service, server),
+                        service,
+                    });
+                    if (postHookResult) {
+                        return handleHandlerOutput(postHookResult, response);
+                    }
+                }
+                return handleHandlerOutput(preHandlerResult, response);
             }
             catch (error) {
                 service.logger.error(ensureError(error));
                 if (options.throwErrorsForExternalHandling) {
                     throw error;
+                    /* node:coverage ignore next 5 */
+                }
+                else if (response.sent) {
+                    assert.never("Error encountered but response was already sent so there's nothing we can do about it.");
                 }
-                else if (!response.sent) {
+                else {
                     response.statusCode = HttpStatus.InternalServerError;
-                    response.send();
+                    return response.send();
                 }
             }
         });
-        const postHook = service.postHook;
-        if (postHook) {
-            server.addHook('onSend', async (request, response, body) => {
-                /* node:coverage ignore next 4 */
-                const restVirContext = request.restVirContext?.[attachId];
-                if (!restVirContext) {
-                    return undefined;
-                }
-                const context = restVirContext.context;
-                const requestData = restVirContext.requestData;
-                const searchParams = restVirContext.searchParams;
-                const pathMatch = matchUrlToService(service, request.originalUrl);
-                /* node:coverage ignore next 10 */
-                if (!pathMatch) {
-                    return undefined;
-                }
-                const endpointDefinition = pathMatch.endpointPath
-                    ? service.endpoints[pathMatch.endpointPath]
-                    : undefined;
-                const webSocketDefinition = request.ws && pathMatch.webSocketPath
-                    ? service.webSockets[pathMatch.webSocketPath]
-                    : undefined;
-                const postHookParams = {
-                    context,
-                    method: assertWrap.isEnumValue(request.method.toUpperCase(), HttpMethod),
-                    request,
-                    requestData,
-                    requestHeaders: request.headers,
-                    response,
-                    service,
-                    endpointDefinition: endpointDefinition,
-                    webSocketDefinition: webSocketDefinition,
-                    server: extractRunningServerInfo(service, server),
-                    searchParams,
-                    originalResponseData: body,
-                    originalStatus: response.statusCode,
-                };
-                const result = await postHook(postHookParams);
-                if (result) {
-                    if (result.headers) {
-                        setResponseHeaders(response, result.headers);
-                    }
-                    if (result.dataType) {
-                        setResponseHeaders(response, {
-                            'content-type': result.dataType,
-                        });
-                    }
-                    if (result.statusCode) {
-                        response.status(result.statusCode);
-                    }
-                    if (isErrorHttpStatus(result.statusCode ?? response.statusCode) &&
-                        'responseErrorMessage' in result) {
-                        if (result.responseErrorMessage == undefined) {
-                            /** Clear the body. */
-                            return null;
-                        }
-                        else {
-                            return result.responseErrorMessage;
-                        }
-                    }
-                    else if ('responseData' in result) {
-                        if (result.responseData == undefined) {
-                            /** Clear the body. */
-                            return null;
-                        }
-                        else {
-                            return result.responseData;
-                        }
-                    }
-                }
-                return undefined;
-            });
-        }
         const allPaths = new Set([
             ...getObjectTypedKeys(service.webSockets),
             ...getObjectTypedKeys(service.endpoints),
@@ -153,17 +107,47 @@ export async function attachService(server, service, options = {}) {
                     method: endpointFastifyMethods,
                     url: path,
                     handler(request, response) {
-                        return handleRoute(undefined, request, response, endpoint, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket: undefined,
+                            request,
+                            response,
+                            route: endpoint,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
                 server.route({
                     method: HttpMethod.Get,
                     url: path,
                     handler(request, response) {
-                        return handleRoute(undefined, request, response, endpoint, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket: undefined,
+                            request,
+                            response,
+                            route: endpoint,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                     wsHandler(webSocket, request) {
-                        return handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket,
+                            request,
+                            response: undefined,
+                            route: webSocketDefinition,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
             }
@@ -175,7 +159,17 @@ export async function attachService(server, service, options = {}) {
                     ],
                     url: path,
                     handler(request, response) {
-                        return handleRoute(undefined, request, response, endpoint, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket: undefined,
+                            request,
+                            response,
+                            route: endpoint,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
             }
@@ -187,7 +181,17 @@ export async function attachService(server, service, options = {}) {
                         return response.status(HttpStatus.NotFound).send();
                     },
                     wsHandler(webSocket, request) {
-                        return handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, extractRunningServerInfo(service, server), options);
+                        return handleRoute({
+                            webSocket,
+                            request,
+                            response: undefined,
+                            route: webSocketDefinition,
+                            attachId,
+                            server: extractRunningServerInfo(service, server),
+                            options,
+                            postHook,
+                            service,
+                        });
                     },
                 });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/run-service",
-    "version": "0.19.0",
+    "version": "0.19.2",
     "description": "Run a service defined by @rest-vir/define-service and implemented by @rest-vir/implement-service.",
     "keywords": [
         "rest",
@@ -39,12 +39,12 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.19.1",
-        "@augment-vir/common": "^31.19.1",
-        "@augment-vir/node": "^31.19.1",
+        "@augment-vir/assert": "^31.20.0",
+        "@augment-vir/common": "^31.20.0",
+        "@augment-vir/node": "^31.20.0",
         "@fastify/websocket": "^11.0.2",
-        "@rest-vir/define-service": "^0.19.0",
-        "@rest-vir/implement-service": "^0.19.0",
+        "@rest-vir/define-service": "^0.19.2",
+        "@rest-vir/implement-service": "^0.19.2",
         "cluster-vir": "^0.1.0",
         "date-vir": "^7.3.1",
         "fastify": "^5.3.3",
@@ -54,10 +54,10 @@
         "url-vir": "^2.1.3"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.19.1",
+        "@augment-vir/test": "^31.20.0",
         "@fastify/multipart": "^9.0.3",
         "@types/connect": "^3.4.38",
-        "@types/node": "^22.15.18",
+        "@types/node": "^22.15.21",
         "@types/ws": "^8.18.1",
         "c8": "^10.1.3",
         "istanbul-smart-text-reporter": "^1.1.5",