@rest-vir/define-service 0.0.2

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

@@ -0,0 +1,198 @@
+import { getOrSet, } from '@augment-vir/common';
+import { parseJsonWithUndefined } from '../augments/json.js';
+import { CommonWebSocketState, } from '../web-socket/common-web-socket.js';
+import { WebSocketLocation, } from '../web-socket/overwrite-web-socket-methods.js';
+/**
+ * Use this to create a mock WebSocket constructor for unit testing Web Socket connection.
+ *
+ * This creates a {@link MockClientWebSocket} constructor for connections from the client side with
+ * types for the given {@link WebSocketDefinition} and utilizing the given
+ * {@link MockClientWebSocketOptions} instance. This can be passed to `connectWebSocket` as the
+ * `webSocketConstructor` to allow unit testing on a client without spinning up an entire host to
+ * serve the WebSocket connection.
+ *
+ * @category Testing : Client (Frontend)
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {
+ *     connectWebSocket,
+ *     createMockClientWebSocketConstructor,
+ * } from '@rest-vir/define-service';
+ *
+ * const webSocket = await connectWebSocket(myService.webSockets['/my-path'], {
+ *     webSocketConstructor: createMockClientWebSocketConstructor(
+ *         myService.webSockets['/my-path'],
+ *         {preventImmediateOpen: true},
+ *     ),
+ * });
+ *
+ * // mock server responses without an actual server
+ * webSocket.sendFromHost(myMessage);
+ * ```
+ *
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function createMockClientWebSocketConstructor(webSocketToConnect, options = {}) {
+    return class extends MockClientWebSocket {
+        constructor(...params) {
+            super(...params, options);
+        }
+    };
+}
+/**
+ * A mock WebSocket constructor for connections from the client side. This can be passed to
+ * `connectWebSocket` as the `webSocketConstructor` to allow unit testing on a client without
+ * spinning up an entire host to serve the WebSocket connection.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {connectWebSocket, MockClientWebSocket} from '@rest-vir/define-service';
+ *
+ * const webSocket = await connectWebSocket(myService.webSockets['/my-path'], {
+ *     webSocketConstructor: MockClientWebSocket<(typeof myService.webSockets)['/my-path']>,
+ * });
+ *
+ * // mock server responses without an actual server
+ * webSocket.sendFromHost(myMessage);
+ * ```
+ *
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export class MockClientWebSocket {
+    /**
+     * Mocked WebSocket event listeners. While this is public, you should attach a listener using
+     * {@link MockClientWebSocket.addEventListener} method and remove them with
+     * {@link MockClientWebSocket.removeEventListener}, as you would with a normal WebSocket
+     * instance.
+     */
+    listeners = {};
+    /**
+     * Implements and mocks the standard `WebSocket.readyState` property.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/WebSocket/readyState
+     */
+    readyState = CommonWebSocketState.Connecting;
+    /**
+     * This callback will be called whenever a message is sent to or from the WebSocket. This is set
+     * via the constructor option `sendCallback`.
+     *
+     * @example
+     *
+     * ```ts
+     * import {MockClientWebSocket, connectWebSocket} from '@rest-vir/define-service';
+     *
+     * const webSocket = await connectWebSocket(myService.webSockets['/my-socket'], {
+     *     webSocketConstructor: createMockClientWebSocketConstructor(
+     *         myService.webSockets['/my-socket'],
+     *         {
+     *             sendCallback: (message) => {
+     *                 // handle the sent message here
+     *                 console.log('handled message:', message);
+     *             },
+     *         },
+     *     ),
+     * });
+     * ```
+     */
+    sendCallback;
+    constructor(...[, , , options = {},]) {
+        if (!options.preventImmediateOpen) {
+            this.open();
+        }
+        if (options.sendCallback) {
+            this.sendCallback = options.sendCallback;
+        }
+    }
+    /**
+     * Manually set the WebSocket connection as opened. This is only necessary to use if you've set
+     * the constructor options to
+     */
+    open() {
+        setTimeout(() => {
+            if (this.readyState === CommonWebSocketState.Connecting) {
+                this.readyState = CommonWebSocketState.Open;
+                this.dispatchEvent('open', {});
+            }
+        });
+    }
+    /** Manually close and cleanup the WebSocket. */
+    close() {
+        this.dispatchEvent('close', {
+            code: 0,
+            reason: 'manually closed',
+            wasClean: true,
+        });
+        this.listeners = {};
+        this.readyState = CommonWebSocketState.Closed;
+    }
+    /**
+     * Dispatch a WebSocket event. This is primarily used within the MockClientWebSocket class
+     * itself but may also be used externally to test various WebSocket scenarios.
+     *
+     * Note that dispatching `'open'` and `'close'` events will not actually close or open the
+     * WebSocket. Use the {@link MockClientWebSocket.open} and {@link MockClientWebSocket.close}
+     * methods instead (which appropriately dispatch their events).
+     */
+    dispatchEvent(eventName, event) {
+        this.listeners[eventName]?.forEach((listener) => listener({
+            ...event,
+            target: this,
+            type: eventName,
+        }));
+    }
+    /**
+     * Implements and mocks the standard `WebSocket.addEventListener` property but with message type
+     * safety.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener
+     */
+    addEventListener(eventName, listener) {
+        getOrSet(this.listeners, eventName, () => new Set()).add(listener);
+    }
+    /**
+     * Implements and mocks the standard `WebSocket.removeEventListener` property but with message
+     * type safety.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener
+     */
+    removeEventListener(eventName, listener) {
+        this.listeners[eventName]?.delete(listener);
+    }
+    /**
+     * Implements and mocks the standard `WebSocket.send` property but with message type safety.
+     *
+     * @see https://developer.mozilla.org/docs/Web/API/WebSocket/send
+     */
+    send(data) {
+        if (this.readyState !== CommonWebSocketState.Open) {
+            return;
+        }
+        void this.sendCallback?.({
+            messageData: parseJsonWithUndefined(data),
+            messageSource: WebSocketLocation.OnClient,
+            webSocket: this,
+        });
+    }
+    /**
+     * Sends a message as if it came from the WebSocket host. Use this to unit test client-side
+     * WebSockets without needing a running host.
+     */
+    sendFromHost(data) {
+        if (this.readyState !== CommonWebSocketState.Open) {
+            return;
+        }
+        this.dispatchEvent('message', {
+            data,
+        });
+        void this.sendCallback?.({
+            messageData: data,
+            messageSource: WebSocketLocation.OnHost,
+            webSocket: this,
+        });
+    }
+}

package/dist/frontend-connect/web-socket-protocol-parse.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names. This is extracted
+ * from the [`ws`](https://www.npmjs.com/package/ws) package. This is used internally to verify if a
+ * set of protocols is valid.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function parseSecWebSocketProtocolHeader(header: string): Set<string>;

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

@@ -0,0 +1,111 @@
+/* eslint-disable unicorn/number-literal-case */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+// cspell:ignore Einar Stangvik Arnout Kazemier Pinca
+/**
+ * This file's contents were extracted from the [`ws`](https://www.npmjs.com/package/ws) package's
+ * following files:
+ *
+ * - https://github.com/websockets/ws/blob/b9ca55b0aa8c72b39a778542bd0fa9b6c455d4c4/lib/subprotocol.js
+ * - https://github.com/websockets/ws/blob/b9ca55b0aa8c72b39a778542bd0fa9b6c455d4c4/lib/validation.js
+ *
+ * That package has the following license:
+ *
+ *     Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+ *     Copyright (c) 2013 Arnout Kazemier and contributors
+ *     Copyright (c) 2016 Luigi Pinca and contributors
+ *
+ *     Permission is hereby granted, free of charge, to any person obtaining a copy of
+ *     this software and associated documentation files (the "Software"), to deal in
+ *     the Software without restriction, including without limitation the rights to
+ *     use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ *     the Software, and to permit persons to whom the Software is furnished to do so,
+ *     subject to the following conditions:
+ *
+ *     The above copyright notice and this permission notice shall be included in all
+ *     copies or substantial portions of the Software.
+ *
+ *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ *     FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ *     COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ *     IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ *     CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars = [
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+    0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+/**
+ * Parses the `Sec-WebSocket-Protocol` header into a set of subprotocol names. This is extracted
+ * from the [`ws`](https://www.npmjs.com/package/ws) package. This is used internally to verify if a
+ * set of protocols is valid.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function parseSecWebSocketProtocolHeader(header) {
+    const protocols = new Set();
+    let start = -1;
+    let end = -1;
+    let i = 0;
+    for (i; i < header.length; i++) {
+        const code = header.codePointAt(i);
+        if (end === -1 && tokenChars[code] === 1) {
+            if (start === -1) {
+                start = i;
+            }
+        }
+        else if (i !== 0 && (code === 0x20 /* ' ' */ || code === 0x09) /* '\t' */) {
+            /* node:coverage ignore next 3: idk how to trigger this */
+            if (end === -1 && start !== -1) {
+                end = i;
+            }
+        }
+        else if (code === 0x2c /* ',' */) {
+            if (start === -1) {
+                throw new SyntaxError(`Unexpected character at index ${i}`);
+            }
+            if (end === -1) {
+                end = i;
+            }
+            const protocol = header.slice(start, end);
+            if (protocols.has(protocol)) {
+                throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+            }
+            protocols.add(protocol);
+            start = end = -1;
+        }
+        else {
+            throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+    }
+    /* node:coverage ignore next 3: idk how to trigger this */
+    if (start === -1 || end !== -1) {
+        throw new SyntaxError('Unexpected end of input');
+    }
+    const protocol = header.slice(start, i);
+    if (protocols.has(protocol)) {
+        throw new SyntaxError(`The "${protocol}" subprotocol is duplicated`);
+    }
+    protocols.add(protocol);
+    return protocols;
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { HttpMethod, HttpStatus } from '@augment-vir/common';
+export * from './augments/json.js';
+export * from './dev-port/find-dev-port.js';
+export * from './endpoint/endpoint-path.js';
+export * from './endpoint/endpoint.js';
+export * from './frontend-connect/connect-web-socket.js';
+export * from './frontend-connect/fetch-endpoint.js';
+export * from './frontend-connect/generate-api.js';
+export * from './frontend-connect/mock-client-web-socket.js';
+export * from './frontend-connect/web-socket-protocol-parse.js';
+export * from './service/define-service.js';
+export * from './service/match-url.js';
+export * from './service/minimal-service.js';
+export * from './service/service-definition.error.js';
+export * from './service/service-definition.js';
+export * from './util/mock-fetch.js';
+export * from './util/no-param.js';
+export * from './util/origin.js';
+export * from './util/path-to-regexp.js';
+export * from './util/search-params.js';
+export * from './web-socket/common-web-socket.js';
+export * from './web-socket/overwrite-web-socket-methods.js';
+export * from './web-socket/web-socket-definition.js';

package/dist/index.js

@@ -0,0 +1,23 @@
+export { HttpMethod, HttpStatus } from '@augment-vir/common';
+export * from './augments/json.js';
+export * from './dev-port/find-dev-port.js';
+export * from './endpoint/endpoint-path.js';
+export * from './endpoint/endpoint.js';
+export * from './frontend-connect/connect-web-socket.js';
+export * from './frontend-connect/fetch-endpoint.js';
+export * from './frontend-connect/generate-api.js';
+export * from './frontend-connect/mock-client-web-socket.js';
+export * from './frontend-connect/web-socket-protocol-parse.js';
+export * from './service/define-service.js';
+export * from './service/match-url.js';
+export * from './service/minimal-service.js';
+export * from './service/service-definition.error.js';
+export * from './service/service-definition.js';
+export * from './util/mock-fetch.js';
+export * from './util/no-param.js';
+export * from './util/origin.js';
+export * from './util/path-to-regexp.js';
+export * from './util/search-params.js';
+export * from './web-socket/common-web-socket.js';
+export * from './web-socket/overwrite-web-socket-methods.js';
+export * from './web-socket/web-socket-definition.js';

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

@@ -0,0 +1,19 @@
+import type { BaseServiceEndpointsInit, BaseServiceWebSocketsInit, ServiceDefinition, ServiceInit } from './service-definition.js';
+/**
+ * The main entry point to the whole `@rest-vir/define-service` package. This function accepts a
+ * {@link ServiceInit} object and returns a fully defined {@link ServiceDefinition}.
+ *
+ * @category Define Service
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function defineService<const ServiceName extends string, EndpointsInit extends BaseServiceEndpointsInit, WebSocketsInit extends BaseServiceWebSocketsInit>(serviceInit: ServiceInit<ServiceName, EndpointsInit, WebSocketsInit>): ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>;
+/**
+ * Asserts that the given input is a valid {@link ServiceDefinition} instance.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @throws {@link ServiceDefinitionError} : if there is an issue
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function assertValidServiceDefinition(serviceDefinition: ServiceDefinition): asserts serviceDefinition is ServiceDefinition;

package/dist/service/define-service.js

@@ -0,0 +1,133 @@
+import { assert, check } from '@augment-vir/assert';
+import { getObjectTypedEntries, mapObjectValues, stringify } from '@augment-vir/common';
+import { assertValidShape, defineShape } from 'object-shape-tester';
+import { assertValidEndpoint, attachEndpointShapeTypeGetters, endpointInitShape, } from '../endpoint/endpoint.js';
+import { assertValidWebSocketDefinition, attachWebSocketShapeTypeGetters, webSocketInitShape, } from '../web-socket/web-socket-definition.js';
+import { ensureServiceDefinitionError } from './service-definition.error.js';
+/**
+ * The main entry point to the whole `@rest-vir/define-service` package. This function accepts a
+ * {@link ServiceInit} object and returns a fully defined {@link ServiceDefinition}.
+ *
+ * @category Define Service
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function defineService(serviceInit) {
+    const serviceDefinition = finalizeServiceDefinition(serviceInit);
+    assertValidServiceDefinition(serviceDefinition);
+    return serviceDefinition;
+}
+function finalizeServiceDefinition(serviceInit) {
+    try {
+        const minimalService = {
+            serviceName: serviceInit.serviceName,
+            serviceOrigin: serviceInit.serviceOrigin,
+            requiredClientOrigin: serviceInit.requiredClientOrigin,
+        };
+        /**
+         * Make the types less strict because we don't care what they are inside of this function's
+         * implementation. Just the return type is what matters.
+         */
+        const genericEndpoints = (serviceInit.endpoints || {});
+        const endpoints = mapObjectValues(genericEndpoints, (endpointPath, endpointInit) => {
+            assertValidShape({ searchParamsShape: undefined, ...endpointInit }, endpointInitShape);
+            const endpoint = {
+                ...endpointInit,
+                requestDataShape: endpointInit.requestDataShape
+                    ? defineShape(endpointInit.requestDataShape, true)
+                    : undefined,
+                responseDataShape: endpointInit.responseDataShape
+                    ? defineShape(endpointInit.responseDataShape, true)
+                    : undefined,
+                path: endpointPath,
+                service: minimalService,
+                customProps: endpointInit.customProps,
+                isEndpoint: true,
+                isWebSocket: false,
+                searchParamsShape: (endpointInit.searchParamsShape
+                    ? defineShape(endpointInit.searchParamsShape)
+                    : undefined),
+            };
+            attachEndpointShapeTypeGetters(endpoint);
+            return endpoint;
+        });
+        const genericWebSockets = (serviceInit.webSockets || {});
+        const webSockets = mapObjectValues(genericWebSockets, (webSocketPath, webSocketInit) => {
+            assertValidShape({ protocolsShape: undefined, searchParamsShape: undefined, ...webSocketInit }, webSocketInitShape);
+            const webSocketDefinition = {
+                ...webSocketInit,
+                messageFromClientShape: webSocketInit.messageFromClientShape
+                    ? defineShape(webSocketInit.messageFromClientShape)
+                    : undefined,
+                messageFromHostShape: webSocketInit.messageFromHostShape
+                    ? defineShape(webSocketInit.messageFromHostShape)
+                    : undefined,
+                protocolsShape: (webSocketInit.protocolsShape
+                    ? defineShape(webSocketInit.protocolsShape)
+                    : undefined),
+                searchParamsShape: (webSocketInit.searchParamsShape
+                    ? defineShape(webSocketInit.searchParamsShape)
+                    : undefined),
+                service: minimalService,
+                path: webSocketPath,
+                customProps: webSocketInit.customProps,
+                isEndpoint: false,
+                isWebSocket: true,
+            };
+            attachWebSocketShapeTypeGetters(webSocketDefinition);
+            return webSocketDefinition;
+        });
+        const serviceDefinition = {
+            serviceName: serviceInit.serviceName,
+            serviceOrigin: serviceInit.serviceOrigin,
+            init: {
+                ...serviceInit,
+                webSockets: (serviceInit.webSockets || {}),
+                endpoints: (serviceInit.endpoints || {}),
+            },
+            webSockets: webSockets,
+            requiredClientOrigin: serviceInit.requiredClientOrigin,
+            /** As cast needed again to narrow the type (for the return value) after broadening it. */
+            endpoints: endpoints,
+        };
+        return serviceDefinition;
+    }
+    catch (error) {
+        throw ensureServiceDefinitionError(error, {
+            path: undefined,
+            serviceName: serviceInit.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+}
+/**
+ * Asserts that the given input is a valid {@link ServiceDefinition} instance.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @throws {@link ServiceDefinitionError} : if there is an issue
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function assertValidServiceDefinition(serviceDefinition) {
+    try {
+        if (!serviceDefinition.serviceName || !check.isString(serviceDefinition.serviceName)) {
+            throw new Error(`Invalid service name: '${stringify(serviceDefinition.serviceName)}'. Expected a non-empty string.`);
+        }
+        assert.isDefined(serviceDefinition.requiredClientOrigin);
+        getObjectTypedEntries(serviceDefinition.endpoints).forEach(([, endpoint,]) => {
+            assertValidEndpoint(endpoint);
+        });
+        getObjectTypedEntries(serviceDefinition.webSockets).forEach(([, webSocketDefinition,]) => {
+            assertValidWebSocketDefinition(webSocketDefinition);
+        });
+    }
+    catch (error) {
+        throw ensureServiceDefinitionError(error, {
+            path: undefined,
+            serviceName: serviceDefinition.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+}

package/dist/service/match-url.d.ts

@@ -0,0 +1,30 @@
+import { type RequireAtLeastOne } from 'type-fest';
+import { EndpointPathBase } from '../endpoint/endpoint-path.js';
+/**
+ * Given a raw path or URL, finds an endpoint or WebSocket path that will match in the given
+ * service. If no match is found, this returns `undefined`.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export declare function matchUrlToService<const Service extends Readonly<{
+    webSockets: Record<EndpointPathBase, any>;
+    endpoints: Record<EndpointPathBase, any>;
+}>>(this: void, service: Service, 
+/** The URL or path to match against. */
+url: string): MatchedServicePath<Service> | undefined;
+/**
+ * Output for {@link matchUrlToService}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type MatchedServicePath<Service extends Readonly<{
+    webSockets: Record<EndpointPathBase, any>;
+    endpoints: Record<EndpointPathBase, any>;
+}>> = RequireAtLeastOne<{
+    webSocketPath: keyof Service['webSockets'];
+    endpointPath: keyof Service['endpoints'];
+}>;

package/dist/service/match-url.js

@@ -0,0 +1,31 @@
+import { getObjectTypedKeys } from '@augment-vir/common';
+import { parseUrl } from 'url-vir';
+import { match } from '../util/path-to-regexp.js';
+/**
+ * Given a raw path or URL, finds an endpoint or WebSocket path that will match in the given
+ * service. If no match is found, this returns `undefined`.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export function matchUrlToService(service, 
+/** The URL or path to match against. */
+url) {
+    const { pathname } = parseUrl(url);
+    const endpointPath = getObjectTypedKeys(service.endpoints).find((endpointPath) => {
+        return match(endpointPath)(pathname);
+    });
+    const webSocketPath = getObjectTypedKeys(service.webSockets).find((webSocketPath) => {
+        return match(webSocketPath)(pathname);
+    });
+    if (!endpointPath && !webSocketPath) {
+        return undefined;
+    }
+    else {
+        return {
+            ...(endpointPath ? { endpointPath } : {}),
+            ...(webSocketPath ? { webSocketPath: webSocketPath } : {}),
+        };
+    }
+}

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

@@ -0,0 +1,44 @@
+import { type IsEqual } from 'type-fest';
+import { type OriginRequirement } from '../util/origin.js';
+/**
+ * This is a minimal service definition with only data to send and handle fetch requests to that
+ * service. Each endpoint definition gets a copy of this embedded into it so the endpoint alone can
+ * be used as an input to the endpoint fetch function.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type MinimalService<ServiceName extends string = string> = {
+    serviceName: IsEqual<ServiceName, ''> extends true ? never : ServiceName;
+    /**
+     * The origin at which the service will be hosted. Fetch requests and WebSocket connections will
+     * be sent to this service will be sent to this origin.
+     *
+     * It is recommended to use a ternary to switch between dev and prod origins.
+     *
+     * @example
+     *
+     * ```ts
+     * import {defineService} from '@rest-vir/define-service';
+     *
+     * defineService({
+     *     serviceOrigin: isDev ? 'http://localhost:3000' : 'https://example.com',
+     * });
+     * ```
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Location for help on which part of the URL is the origin (if necessary).
+     */
+    serviceOrigin: string;
+    /**
+     * The service's `origin` requirement for all endpoint requests and WebSocket connections. This
+     * is used for CORS handshakes.
+     *
+     * This can be a string, a RegExp, a function, or an array of any of those. (If this is an
+     * array, the first matching array element will be used.)
+     *
+     * Set this to `AnyOrigin` (imported from `'@rest-vir/define-service'`) to allow any origins.
+     * Make sure that you're okay with the security impact this may have on your users of doing so.
+     */
+    requiredClientOrigin: NonNullable<OriginRequirement>;
+};

package/dist/service/minimal-service.js

@@ -0,0 +1 @@
+export {};