@rest-vir/run-service 0.18.0 → 0.19.0

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

@@ -42,6 +42,7 @@ export declare function attachService(server: Readonly<FastifyInstance>, service
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>, options?: Readonly<HandleRouteOptions>): Promise<void>;
 /**
  * Merge the running Fastify server's port with the given service's origin port (if it has a port).

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

@@ -1,10 +1,12 @@
-import { check } from '@augment-vir/assert';
-import { ensureError, extractErrorMessage, getEnumValues, getObjectTypedKeys, HttpMethod, HttpStatus, randomString, } from '@augment-vir/common';
+import { assertWrap, check } from '@augment-vir/assert';
+import { ensureError, extractErrorMessage, getEnumValues, getObjectTypedKeys, HttpMethod, HttpStatus, isErrorHttpStatus, 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 { handleRoute } from '../handle-request/handle-route.js';
 import { preHandler } from '../handle-request/pre-handler.js';
+import { setResponseHeaders } from '../util/headers.js';
 const endpointFastifyMethods = getEnumValues(HttpMethod).filter((value) => {
     return (
     /** Fastify doesn't support the CONNECT method. */
@@ -66,6 +68,79 @@ export async function attachService(server, service, options = {}) {
                 }
             }
         });
+        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),

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

@@ -69,4 +69,5 @@ export declare function startService(service: Readonly<SelectFrom<GenericService
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>, userOptions?: Readonly<StartServiceUserOptions>, fastifyPlugins?: Readonly<FastifyPlugins>): Promise<StartServiceOutput>;

package/dist/test/test-service.d.ts

@@ -284,6 +284,7 @@ export declare function testService<const Service extends Readonly<SelectFrom<Ge
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>>(service: Readonly<Service>, testServiceOptions?: Readonly<Omit<PartialWithUndefined<StartServiceUserOptions>, 'workerCount' | 'preventWorkerRespawn' | ''>>): Promise<{
     /** Kill the server being tested. This should always be called after your tests are finished. */
     kill(this: void): Promise<void>;
@@ -313,6 +314,7 @@ export declare function testExistingServer<const Service extends Readonly<Select
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>>(server: Readonly<FastifyInstance>, service: Readonly<Service>, options?: Readonly<HandleRouteOptions & Omit<PartialWithUndefined<StartServiceOptions>, 'workerCount' | 'preventWorkerRespawn'>>): Promise<{
     /** Send a request to the service. */
     fetchEndpoint: FetchTestService<Service>;
@@ -353,6 +355,7 @@ export declare function describeService<const Service extends Readonly<SelectFro
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
+    postHook: true;
 }>>>({ service, options, }: {
     /** The service to startup and send requests to. */
     service: Readonly<Service>;

package/dist/test/test-service.js

@@ -182,7 +182,7 @@ export async function testExistingServer(server, service, options = {}) {
             const webSocketUrl = buildWebSocketUrl(overwrittenOriginWebSocket, ...args);
             assertValidWebSocketProtocols(protocols);
             const webSocket = webSocketOrigin == undefined
-                ? (await server.injectWS(parseUrl(webSocketUrl).pathname, protocols.length
+                ? (await server.injectWS(parseUrl(webSocketUrl).fullPath, protocols.length
                     ? {
                         headers: {
                             'sec-websocket-protocol': protocols.join(', '),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/run-service",
-    "version": "0.18.0",
+    "version": "0.19.0",
     "description": "Run a service defined by @rest-vir/define-service and implemented by @rest-vir/implement-service.",
     "keywords": [
         "rest",
@@ -39,25 +39,25 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.16.0",
-        "@augment-vir/common": "^31.16.0",
-        "@augment-vir/node": "^31.16.0",
+        "@augment-vir/assert": "^31.19.1",
+        "@augment-vir/common": "^31.19.1",
+        "@augment-vir/node": "^31.19.1",
         "@fastify/websocket": "^11.0.2",
-        "@rest-vir/define-service": "^0.18.0",
-        "@rest-vir/implement-service": "^0.18.0",
+        "@rest-vir/define-service": "^0.19.0",
+        "@rest-vir/implement-service": "^0.19.0",
         "cluster-vir": "^0.1.0",
         "date-vir": "^7.3.1",
-        "fastify": "^5.3.2",
+        "fastify": "^5.3.3",
         "light-my-request": "^6.6.0",
         "portfinder": "^1.0.37",
-        "type-fest": "^4.40.1",
+        "type-fest": "^4.41.0",
         "url-vir": "^2.1.3"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.16.0",
+        "@augment-vir/test": "^31.19.1",
         "@fastify/multipart": "^9.0.3",
         "@types/connect": "^3.4.38",
-        "@types/node": "^22.15.3",
+        "@types/node": "^22.15.18",
         "@types/ws": "^8.18.1",
         "c8": "^10.1.3",
         "istanbul-smart-text-reporter": "^1.1.5",