@rest-vir/run-service 0.11.0 → 0.11.2

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

@@ -1,5 +1,6 @@
 import { type HttpStatus, type MaybePromise, type PartialWithUndefined } from '@augment-vir/common';
 import { ServerRequest, ServerResponse, type ImplementedEndpoint, type ImplementedWebSocket } from '@rest-vir/implement-service';
+import type { FastifyReply } from 'fastify';
 import { OutgoingHttpHeaders } from 'node:http';
 /**
  * Options for `handleRoute`.
@@ -71,6 +72,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): {
-    responseSent: boolean;
-};
+export declare function handleHandlerResult(result: Readonly<HandledOutput>, response: ServerResponse): undefined | FastifyReply;

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

@@ -14,16 +14,11 @@ export function handleHandlerResult(result, response) {
     if (result?.statusCode) {
         response.statusCode = result.statusCode;
         if (result.body) {
-            response.send(result.body);
+            return response.send(result.body);
         }
         else {
-            response.send();
+            return response.send();
         }
-        return {
-            responseSent: true,
-        };
     }
-    return {
-        responseSent: false,
-    };
+    return undefined;
 }

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

@@ -39,7 +39,7 @@ export async function handleEndpointRequest({ endpoint, request, response, attac
             };
         }
         else if (endpointResult.responseData) {
-            if (!endpoint.responseDataShape) {
+            if (endpoint.responseDataShape == undefined) {
                 throw new RestVirHandlerError(endpoint, 'Got response data but none was expected.');
             }
             assertValidShape(endpointResult.responseData, endpoint.responseDataShape, { allowExtraKeys: true }, 'invalid response data');

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

@@ -35,19 +35,19 @@ response, route, attachId, options = {}) {
                 endpoint: route,
                 attachId,
             });
-            if (handleHandlerResult(result, response).responseSent) {
-                return;
+            const sentResponse = handleHandlerResult(result, response);
+            if (sentResponse) {
+                return sentResponse;
             }
         }
         else if (route.isWebSocket) {
             assert.isDefined(webSocket);
-            await handleWebSocketRequest({
+            return await handleWebSocketRequest({
                 request,
                 implementedWebSocket: route,
                 webSocket,
                 attachId,
             });
-            return;
         }
         /* node:coverage ignore next: this can't actually be triggered but it should be covered as a potential future edge case. */
         throw new RestVirHandlerError(route, 'Request was not handled.');

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

@@ -1,5 +1,6 @@
 import { type SelectFrom } from '@augment-vir/common';
 import { GenericServiceImplementation, ServerRequest, ServerResponse } from '@rest-vir/implement-service';
+import { type FastifyReply } from 'fastify';
 /**
  * Handles a request before it gets to the actual route handlers.
  *
@@ -15,4 +16,4 @@ export declare function preHandler(request: ServerRequest, response: ServerRespo
     serviceOrigin: true;
     requiredClientOrigin: true;
     logger: true;
-}>>, attachId: string): Promise<void>;
+}>>, attachId: string): Promise<FastifyReply | undefined>;

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

@@ -19,7 +19,7 @@ export async function preHandler(request, response, service, attachId) {
     const pathMatch = matchUrlToService(service, request.originalUrl);
     if (!pathMatch) {
         /** Nothing to do. */
-        return;
+        return undefined;
     }
     const endpointDefinition = pathMatch.endpointPath
         ? service.endpoints[pathMatch.endpointPath]
@@ -29,7 +29,7 @@ export async function preHandler(request, response, service, attachId) {
         : undefined;
     const route = endpointDefinition || webSocketDefinition;
     if (!route) {
-        return;
+        return undefined;
     }
     const protocols = webSocketDefinition
         ? (request.headers['sec-websocket-protocol'] || '').split(', ')
@@ -43,24 +43,25 @@ export async function preHandler(request, response, service, attachId) {
         service.logger.error(new RestVirHandlerError(route, extractErrorMessage(ensureErrorAndPrependMessage(protocolShapeError, `WebSocket protocols rejected (${stringify(protocols)}):`))));
         response.statusCode = HttpStatus.BadRequest;
         response.send('Invalid protocols.');
-        return;
+        return undefined;
     }
-    if (handleHandlerResult(await handleCors({
+    const subHandlerResponse = handleHandlerResult(await handleCors({
         request,
         route,
-    }), response).responseSent ||
+    }), response) ||
         handleHandlerResult(handleRequestMethod({
             request,
             route,
-        }), response).responseSent) {
-        return;
+        }), response);
+    if (subHandlerResponse) {
+        return subHandlerResponse;
     }
     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;
+        return undefined;
     }
     const contextParams = {
         method: assertWrap.isEnumValue(request.method.toUpperCase(), HttpMethod),
@@ -74,19 +75,17 @@ export async function preHandler(request, response, service, attachId) {
     };
     const searchParams = handleSearchParams({ request, route });
     if (!('data' in searchParams)) {
-        handleHandlerResult(searchParams, response);
-        return;
+        return handleHandlerResult(searchParams, response);
     }
     try {
         const contextOutput = await service.createContext?.(contextParams);
         if (contextOutput?.reject) {
             service.logger.error(new RestVirHandlerError(route, `Context creation rejected: '${request.originalUrl}'`));
-            handleHandlerResult({
+            return handleHandlerResult({
                 body: contextOutput.reject.responseErrorMessage,
                 statusCode: contextOutput.reject.statusCode,
                 headers: contextOutput.reject.headers,
             }, response);
-            return;
         }
         if (!request.restVirContext) {
             request.restVirContext = {};
@@ -97,6 +96,7 @@ export async function preHandler(request, response, service, attachId) {
             protocols,
             searchParams: searchParams.data,
         };
+        return undefined;
     }
     catch (error) {
         throw ensureErrorAndPrependMessage(error, 'Failed to generate request context.');
@@ -104,7 +104,7 @@ export async function preHandler(request, response, service, attachId) {
 }
 function extractRequestData(body, headers, route) {
     const dataShape = 'requestDataShape' in route ? route.requestDataShape : undefined;
-    if (!dataShape) {
+    if (dataShape == undefined) {
         if (body) {
             throw new Error(`Did not expect any request data but received it.`);
         }

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

@@ -51,7 +51,7 @@ export async function attachService(server, service, options = {}) {
         }
         server.addHook('preValidation', async (request, response) => {
             try {
-                await preHandler(request, response, service, attachId);
+                return await preHandler(request, response, service, attachId);
             }
             catch (error) {
                 service.logger.error(ensureError(error));
@@ -75,18 +75,18 @@ export async function attachService(server, service, options = {}) {
                 server.route({
                     method: endpointFastifyMethods,
                     url: path,
-                    async handler(request, response) {
-                        await handleRoute(undefined, request, response, endpoint, attachId, options);
+                    handler(request, response) {
+                        return handleRoute(undefined, request, response, endpoint, attachId, options);
                     },
                 });
                 server.route({
                     method: HttpMethod.Get,
                     url: path,
-                    async handler(request, response) {
-                        await handleRoute(undefined, request, response, endpoint, attachId, options);
+                    handler(request, response) {
+                        return handleRoute(undefined, request, response, endpoint, attachId, options);
                     },
-                    async wsHandler(webSocket, request) {
-                        await handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, options);
+                    wsHandler(webSocket, request) {
+                        return handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, options);
                     },
                 });
             }
@@ -97,8 +97,8 @@ export async function attachService(server, service, options = {}) {
                         HttpMethod.Get,
                     ],
                     url: path,
-                    async handler(request, response) {
-                        await handleRoute(undefined, request, response, endpoint, attachId, options);
+                    handler(request, response) {
+                        return handleRoute(undefined, request, response, endpoint, attachId, options);
                     },
                 });
             }
@@ -107,10 +107,10 @@ export async function attachService(server, service, options = {}) {
                     method: HttpMethod.Get,
                     url: path,
                     handler(request, response) {
-                        response.status(HttpStatus.NotFound).send();
+                        return response.status(HttpStatus.NotFound).send();
                     },
-                    async wsHandler(webSocket, request) {
-                        await handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, options);
+                    wsHandler(webSocket, request) {
+                        return handleRoute(webSocket, request, undefined, webSocketDefinition, attachId, options);
                     },
                 });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/run-service",
-    "version": "0.11.0",
+    "version": "0.11.2",
     "description": "Run a service defined by @rest-vir/define-service and implemented by @rest-vir/implement-service.",
     "keywords": [
         "rest",
@@ -43,8 +43,8 @@
         "@augment-vir/common": "^31.10.2",
         "@augment-vir/node": "^31.10.2",
         "@fastify/websocket": "^11.0.2",
-        "@rest-vir/define-service": "^0.11.0",
-        "@rest-vir/implement-service": "^0.11.0",
+        "@rest-vir/define-service": "^0.11.2",
+        "@rest-vir/implement-service": "^0.11.2",
         "cluster-vir": "^0.1.0",
         "date-vir": "^7.3.1",
         "fastify": "^5.2.2",