@rest-vir/define-service 1.4.0 → 1.5.1

package/dist/augments/json.js

@@ -7,7 +7,10 @@ import { wrapInTry } from '@augment-vir/common';
  * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
  */
 export function parseJsonWithUndefined(data) {
+    if (!data || data === 'undefined') {
+        return undefined;
+    }
     return wrapInTry(() => JSON.parse(data), {
-        fallbackValue: data === 'undefined' ? undefined : data,
+        fallbackValue: data,
     });
 }

package/dist/dev-port/find-dev-port.js

@@ -97,7 +97,9 @@ export async function findDevServicePort(service, options = {}) {
  * @throws Error if the max scan distance has been reached without finding a valid port.
  * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
  */
-export async function findLivePort(originWithStartingPort, pathToCheck, { fetch = globalThis.fetch, maxScanDistance = 100, isValidResponse, timeout = { seconds: 10 }, } = {}) {
+export async function findLivePort(originWithStartingPort, pathToCheck, { fetch = globalThis.fetch, maxScanDistance = 100, isValidResponse, timeout = {
+    seconds: 10,
+}, } = {}) {
     const { port: originalPort } = parseUrl(originWithStartingPort);
     if (!originalPort) {
         return undefined;
@@ -106,7 +108,9 @@ export async function findLivePort(originWithStartingPort, pathToCheck, { fetch
     assert.isNumber(startingPort, `Given origin doesn't have a valid port.`);
     let findDistance = 0;
     let foundValidPort = false;
-    const timeoutMs = convertDuration(timeout, { milliseconds: true }).milliseconds;
+    const timeoutMs = convertDuration(timeout, {
+        milliseconds: true,
+    }).milliseconds;
     const startTime = Date.now();
     while (!foundValidPort) {
         const port = findDistance + startingPort;

package/dist/endpoint/endpoint.d.ts

@@ -104,7 +104,7 @@ export declare const endpointInitShape: Shape<{
     }> | import("@sinclair/typebox").TUnsafe<RegExp> | import("@sinclair/typebox").TString | import("@sinclair/typebox").TUndefined | import("@sinclair/typebox").TUnsafe<() => void> | import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<(import("@sinclair/typebox").TUnsafe<{
         anyOrigin: boolean;
     }> | import("@sinclair/typebox").TUnsafe<RegExp> | import("@sinclair/typebox").TString | import("@sinclair/typebox").TUnsafe<() => void>)[]>>)[]>>>;
-    methods: import("@sinclair/typebox").TUnsafe<Partial<Record<HttpMethod, boolean>>>;
+    methods: Shape<import("@sinclair/typebox").TUnsafe<Partial<Record<HttpMethod, boolean>>>>;
     bypassResponseValidation: Shape<import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<(import("@sinclair/typebox").TBoolean | import("@sinclair/typebox").TNull | import("@sinclair/typebox").TUndefined)[]>>>;
     customProps: Shape<import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<(import("@sinclair/typebox").TUndefined | import("@sinclair/typebox").TUnsafe<Record<never, unknown>>)[]>>>;
 }>;

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

@@ -41,7 +41,10 @@ export function buildWebSocketUrl(webSocketDefinition, ...[{ pathParams, searchP
         responseDataShape: undefined,
         service: webSocketDefinition.service,
         searchParamsShape: webSocketDefinition.searchParamsShape,
-    }, { pathParams, searchParams });
+    }, {
+        pathParams,
+        searchParams,
+    });
     return buildUrl(httpUrl, {
         protocol: httpUrl.startsWith('https') ? 'wss' : 'ws',
     }).href;

package/dist/frontend-connect/fetch-endpoint.d.ts

@@ -95,7 +95,10 @@ export type FetchEndpointOutput<EndpointToFetch extends Readonly<SelectFrom<Endp
     response: Readonly<Response>;
 }> | Readonly<{
     ok: false;
-    data: string | undefined;
+    data: EndpointToFetch extends SelectFrom<EndpointDefinition, {
+        requestDataShape: true;
+        responseDataShape: true;
+    }> ? EndpointExecutorData<EndpointToFetch>['response'] | string | undefined : any;
     response: Readonly<Response>;
 }>;
 /**

package/dist/frontend-connect/fetch-endpoint.js

@@ -1,6 +1,6 @@
 import { check } from '@augment-vir/assert';
 import { addPrefix, filterMap, getObjectTypedEntries, HttpMethod, mapObject, } from '@augment-vir/common';
-import { assertValidShape } from 'object-shape-tester';
+import { assertValidShape, checkWrapValidShape } from 'object-shape-tester';
 import { buildUrl } from 'url-vir';
 import { parseJsonWithUndefined } from '../augments/json.js';
 function defaultFetch(...[url, requestInit,]) {
@@ -55,7 +55,9 @@ export async function fetchEndpoint(endpoint, ...params) {
     const { requestData, fetch, bypassResponseValidation } = params[0] || {};
     if (requestData) {
         if (endpoint.requestDataShape) {
-            assertValidShape(requestData, endpoint.requestDataShape, { allowExtraKeys: true });
+            assertValidShape(requestData, endpoint.requestDataShape, {
+                allowExtraKeys: true,
+            });
         }
         else {
             throw new Error(`Request data was given but endpoint '${endpoint.path}' is not expecting any request data.`);
@@ -64,12 +66,15 @@ export async function fetchEndpoint(endpoint, ...params) {
     const { requestInit, url } = buildEndpointRequestInit(endpoint, ...params);
     /* node:coverage ignore next: all tests mock fetch so we're never going to have a fallback here. */
     const response = await (fetch || defaultFetch)(url, requestInit, endpoint);
+    const responseText = await response.clone().text();
+    const responseData = endpoint.responseDataShape
+        ? parseJsonWithUndefined(responseText)
+        : undefined;
     if (response.ok) {
-        const responseData = endpoint.responseDataShape
-            ? parseJsonWithUndefined(await response.text())
-            : undefined;
         if (endpoint.responseDataShape && !bypassResponseValidation) {
-            assertValidShape(responseData, endpoint.responseDataShape, { allowExtraKeys: true });
+            assertValidShape(responseData, endpoint.responseDataShape, {
+                allowExtraKeys: true,
+            });
         }
         return {
             ok: true,
@@ -78,10 +83,16 @@ export async function fetchEndpoint(endpoint, ...params) {
         };
     }
     else {
+        const validResponseData = endpoint.responseDataShape
+            ? bypassResponseValidation
+                ? responseData
+                : checkWrapValidShape(responseData, endpoint.responseDataShape, {
+                    allowExtraKeys: true,
+                })
+            : undefined;
         return {
             ok: false,
-            /** This will be an error message. */
-            data: (await response.text()) || undefined,
+            data: validResponseData || responseText || undefined,
             response,
         };
     }
@@ -172,7 +183,10 @@ export function buildEndpointUrl(endpoint, { pathParams, searchParams, wildcard,
             throw new Error(`Missing value for path param '${paramName}'.`);
         }
     })
-        .replace(/\/\*$/, addPrefix({ value: wildcard || '', prefix: '/' }));
+        .replace(/\/\*$/, addPrefix({
+        value: wildcard || '',
+        prefix: '/',
+    }));
     const builtUrl = buildUrl(endpoint.service.serviceOrigin, {
         search: searchParams,
         pathname,

package/dist/service/define-service.js

@@ -30,7 +30,10 @@ function finalizeServiceDefinition(serviceInit) {
          */
         const genericEndpoints = (serviceInit.endpoints || {});
         const endpoints = mapObjectValues(genericEndpoints, (endpointPath, endpointInit) => {
-            assertValidShape({ searchParamsShape: undefined, ...endpointInit }, endpointInitShape);
+            assertValidShape({
+                searchParamsShape: undefined,
+                ...endpointInit,
+            }, endpointInitShape);
             const endpoint = {
                 ...endpointInit,
                 requestDataShape: endpointInit.requestDataShape == undefined
@@ -53,7 +56,11 @@ function finalizeServiceDefinition(serviceInit) {
         });
         const genericWebSockets = (serviceInit.webSockets || {});
         const webSockets = mapObjectValues(genericWebSockets, (webSocketPath, webSocketInit) => {
-            assertValidShape({ protocolsShape: undefined, searchParamsShape: undefined, ...webSocketInit }, webSocketInitShape);
+            assertValidShape({
+                protocolsShape: undefined,
+                searchParamsShape: undefined,
+                ...webSocketInit,
+            }, webSocketInitShape);
             const webSocketDefinition = {
                 ...webSocketInit,
                 messageFromClientShape: webSocketInit.messageFromClientShape

package/dist/service/match-url.js

@@ -24,8 +24,16 @@ url) {
     }
     else {
         return {
-            ...(endpointPath ? { endpointPath } : {}),
-            ...(webSocketPath ? { webSocketPath } : {}),
+            ...(endpointPath
+                ? {
+                    endpointPath,
+                }
+                : {}),
+            ...(webSocketPath
+                ? {
+                    webSocketPath,
+                }
+                : {}),
         };
     }
 }

package/dist/util/path-to-regexp.js

@@ -90,23 +90,47 @@ function* lexer(str) {
         const value = chars[i];
         const type = SIMPLE_TOKENS[value];
         if (type) {
-            yield { type, index: i++, value };
+            yield {
+                type,
+                index: i++,
+                value,
+            };
         }
         else if (value === '\\') {
-            yield { type: 'ESCAPED', index: i++, value: chars[i++] };
+            yield {
+                type: 'ESCAPED',
+                index: i++,
+                value: chars[i++],
+            };
         }
         else if (value === ':') {
             const value = name();
-            yield { type: 'PARAM', index: i, value };
+            yield {
+                type: 'PARAM',
+                index: i,
+                value,
+            };
         }
         else if (value === '*') {
-            yield { type: 'WILDCARD', index: i++, value: '*' };
+            yield {
+                type: 'WILDCARD',
+                index: i++,
+                value: '*',
+            };
         }
         else {
-            yield { type: 'CHAR', index: i, value: chars[i++] };
+            yield {
+                type: 'CHAR',
+                index: i,
+                value: chars[i++],
+            };
         }
     }
-    return { type: 'END', index: i, value: '' };
+    return {
+        type: 'END',
+        index: i,
+        value: '',
+    };
 }
 class Iter {
     tokens;
@@ -162,7 +186,10 @@ function parse(stringToParse) {
         while (true) {
             const path = iterator.text();
             if (path) {
-                tokens.push({ type: 'text', value: path });
+                tokens.push({
+                    type: 'text',
+                    value: path,
+                });
             }
             const param = iterator.tryConsume('PARAM');
             if (param) {
@@ -227,7 +254,10 @@ export function match(path) {
             const decoder = decoders[i - 1];
             params[key.name] = decoder(m[i]);
         }
-        return { path, params };
+        return {
+            path,
+            params,
+        };
     };
 }
 function pathToRegexp(path) {
@@ -241,7 +271,10 @@ function pathToRegexp(path) {
     pattern += `(?:${escape(DEFAULT_DELIMITER)}$)?`;
     pattern += '$';
     const regexp = new RegExp(pattern, flags);
-    return { regexp, keys };
+    return {
+        regexp,
+        keys,
+    };
 }
 /** Path or array of paths to normalize. */
 function* flat(path) {
@@ -300,7 +333,7 @@ function negate(delimiter, backtrack) {
         }
         return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;
     }
-    if (delimiter.length < 2) {
+    else if (delimiter.length < 2) {
         return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;
     }
     return String.raw `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\s\S])`;

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

@@ -103,7 +103,9 @@ export function overwriteWebSocketMethods(webSocketDefinition, rawWebSocket, web
                 originalRemoveEventListener.call(webSocket, eventName, existing);
             }
         },
-        async sendAndWaitForReply({ message, timeout = { seconds: 10 }, replyCheck, } = {}) {
+        async sendAndWaitForReply({ message, timeout = {
+            seconds: 10,
+        }, replyCheck, } = {}) {
             const deferredReply = new DeferredPromise();
             async function listener({ message, }) {
                 if (!deferredReply.isSettled) {
@@ -119,7 +121,9 @@ export function overwriteWebSocketMethods(webSocketDefinition, rawWebSocket, web
                 if (!deferredReply.isSettled) {
                     deferredReply.reject('Timeout: got no reply from the host.');
                 }
-            }, convertDuration(timeout, { milliseconds: true }).milliseconds);
+            }, convertDuration(timeout, {
+                milliseconds: true,
+            }).milliseconds);
             webSocket.addEventListener('message', listener);
             webSocket.send(message);
             try {
@@ -174,7 +178,7 @@ export async function waitForOpenWebSocket(webSocket) {
         if (webSocketOpenedPromise.isSettled) {
             return true;
         }
-        if (webSocket.readyState === CommonWebSocketState.Closed) {
+        else if (webSocket.readyState === CommonWebSocketState.Closed) {
             webSocketOpenedPromise.reject('WebSocket closed while waiting for it to open.');
             return true;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rest-vir/define-service",
-    "version": "1.4.0",
+    "version": "1.5.1",
     "description": "Define an connect to a declarative and type safe REST and WebSocket service.",
     "keywords": [
         "rest",
@@ -40,24 +40,24 @@
         "test:update": "npm test update"
     },
     "dependencies": {
-        "@augment-vir/assert": "^31.55.0",
-        "@augment-vir/common": "^31.55.0",
-        "date-vir": "^8.1.0",
-        "type-fest": "^5.3.1",
+        "@augment-vir/assert": "^31.68.1",
+        "@augment-vir/common": "^31.68.1",
+        "date-vir": "^8.2.1",
+        "type-fest": "^5.4.4",
         "url-vir": "^2.1.7"
     },
     "devDependencies": {
-        "@augment-vir/test": "^31.55.0",
-        "@web/dev-server-esbuild": "^1.0.4",
+        "@augment-vir/test": "^31.68.1",
+        "@web/dev-server-esbuild": "^1.0.5",
         "@web/test-runner": "^0.20.2",
         "@web/test-runner-commands": "^0.9.0",
         "@web/test-runner-playwright": "^0.11.1",
         "@web/test-runner-visual-regression": "^0.10.0",
         "istanbul-smart-text-reporter": "^1.1.5",
         "markdown-code-example-inserter": "^3.0.3",
-        "object-shape-tester": "^6.10.1",
-        "typedoc": "^0.28.15",
-        "ws": "^8.18.3"
+        "object-shape-tester": "^6.11.0",
+        "typedoc": "^0.28.17",
+        "ws": "^8.19.0"
     },
     "peerDependencies": {
         "object-shape-tester": ">=5"