@rest-vir/define-service 0.0.2

package/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 electrovir
+
+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.

package/README.md

@@ -0,0 +1,88 @@
+# @rest-vir/define-service
+
+Part of the rest-vir suite. This package is used for defining a declarative and type safe REST service with both endpoints and WebSockets.
+
+See the full docs at https://electrovir.github.io/rest-vir
+
+## Installation
+
+```sh
+npm i @rest-vir/define-service
+```
+
+## Usage
+
+Define your service:
+
+<!-- example-link: src/examples/my-service.example.ts -->
+
+```TypeScript
+import {AnyOrigin, defineService, HttpMethod} from '@rest-vir/define-service';
+
+export const myService = defineService({
+    /** The name of your service. This will be visible to all consumers of this service definition. */
+    serviceName: 'my-service',
+    /**
+     * 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.
+     */
+    serviceOrigin: isDev ? 'http://localhost:3000' : 'https://example.com',
+    /**
+     * 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: AnyOrigin,
+    endpoints: {
+        '/my-endpoint': {
+            /** This endpoint requires all requests to contain a string body. */
+            requestDataShape: '',
+            /** This endpoint's response body will always be empty. */
+            responseDataShape: undefined,
+
+            methods: {
+                [HttpMethod.Post]: true,
+            },
+        },
+        /** Express-style path params are allowed. */
+        '/my-endpoint/:user-id': {
+            /** This endpoint expects no request body data. */
+            requestDataShape: undefined,
+            /**
+             * This endpoint will always response with data that matches:
+             *
+             *     {
+             *         username: string,
+             *         firstName: string,
+             *         lastName: string
+             *     }
+             */
+            responseDataShape: {
+                username: '',
+                firstName: '',
+                lastName: '',
+            },
+            methods: {
+                [HttpMethod.Get]: true,
+            },
+            /** Each endpoint may override the service's origin requirement. */
+            requiredClientOrigin: 'https://example.com',
+        },
+    },
+    webSockets: {
+        '/my-web-socket': {
+            /** This WebSocket requires all messages from the client to be a string. */
+            messageFromClientShape: '',
+            /** Same for messages from the host. */
+            messageFromHostShape: '',
+        },
+    },
+});
+```

package/dist/augments/json.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parses a JSON string and converts `'undefined'` to `undefined`.
+ *
+ * @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 parseJsonWithUndefined(data: string): any;

package/dist/augments/json.js

@@ -0,0 +1,13 @@
+import { wrapInTry } from '@augment-vir/common';
+/**
+ * Parses a JSON string and converts `'undefined'` to `undefined`.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function parseJsonWithUndefined(data) {
+    return wrapInTry(() => JSON.parse(data), {
+        fallbackValue: data === 'undefined' ? undefined : data,
+    });
+}

package/dist/dev-port/find-dev-port.d.ts

@@ -0,0 +1,132 @@
+import { type MaybePromise, type PartialWithUndefined, type SelectFrom } from '@augment-vir/common';
+import { type AnyDuration } from 'date-vir';
+import type { EndpointPathBase } from '../endpoint/endpoint-path.js';
+import { GenericFetchEndpointParams } from '../frontend-connect/fetch-endpoint.js';
+import type { ServiceDefinition } from '../service/service-definition.js';
+/**
+ * This header is set on all responses handled by rest-vir so we know what service a response came
+ * from.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare const restVirServiceNameHeader = "rest-vir-service";
+/**
+ * Options for {@link findDevServicePort} and {@link findLivePort}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type FindPortOptions = Pick<GenericFetchEndpointParams, 'fetch'> & PartialWithUndefined<{
+    /**
+     * The maximum number of ports that are scanned before giving up.
+     *
+     * @default 100
+     */
+    maxScanDistance: number;
+    /**
+     * A callback that is used to determine if a port's response is valid.
+     *
+     * If this is not provided, the check is simply `!!response.ok`.
+     *
+     * If this is provided, returning `true` determines that a port response is valid. This will
+     * only be called if `response.ok` is already `true`.
+     */
+    isValidResponse: (response: Readonly<Response>) => MaybePromise<boolean>;
+    /**
+     * Max duration that port finding is allowed to go on for.
+     *
+     * @default {seconds: 10}
+     */
+    timeout: AnyDuration;
+    /**
+     * A starting origin used to replace the service definition's origin, in case you need to
+     * keep your service definition's origin static for API publishing purposes.
+     *
+     * This defaults to whatever origin is already set on the given service definition.
+     */
+    startingOriginOverride: string;
+}>;
+/**
+ * Use this to find a service's port number when started without a locked-in port. This allows a
+ * client (usually a website frontend) to find which port the server started on by scanning ports
+ * starting with the port defined in the service's `serviceOrigin` property.
+ *
+ * If the service has no port in its `serviceOrigin` property, this function throws an error.
+ *
+ * Note that the service given must have at least one endpoint defined for this function to work.
+ *
+ * This is used in `defineService` if the `findActiveDevPort` option is set to true.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {findDevServicePort, defineService, AnyOrigin} from '@rest-vir/define-service';
+ *
+ * const myService = defineService({
+ *     serviceName: 'my-service',
+ *     serviceOrigin: 'https://localhost:3000',
+ *     requiredClientOrigin: AnyOrigin,
+ *     endpoints: {
+ *         '/my-path': {
+ *             methods: {
+ *                 [HttpMethod.Get]: true,
+ *             },
+ *             requestDataShape: undefined,
+ *             responseDataShape: undefined,
+ *         },
+ *     },
+ * });
+ *
+ * const {origin} = await findDevServicePort(myService);
+ * ```
+ *
+ * @throws Error if no valid starting port can be found or 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 declare function findDevServicePort(service: Readonly<SelectFrom<ServiceDefinition, {
+    endpoints: true;
+    serviceOrigin: true;
+    serviceName: true;
+}>>, options?: Readonly<Omit<FindPortOptions, 'isValidResponse'>>): Promise<{
+    port: number;
+    origin: string;
+}>;
+/**
+ * Find the first port, starting with the port in the given origin, that, with the given path, is
+ * alive and matches, if provided, `isValidResponse`.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @throws Error if no valid starting port can be found or 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 declare function findLivePort(originWithStartingPort: string, pathToCheck: EndpointPathBase, { fetch, maxScanDistance, isValidResponse, timeout, }?: Readonly<Omit<FindPortOptions, 'overwriteOrigin'>>): Promise<number>;
+/**
+ * Creates a copy of a service definition (without mutating the original service definition) that
+ * maps the service's origin port to find the live port that's actually running.
+ *
+ * This is useful for situations in dev where backend automatically starts on a different port if
+ * the original port is already in use.
+ *
+ * @category Client (Frontend) Connection
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {mapServiceDevPort} from '@rest-vir/define-service';
+ *
+ * const mappedService = await mapServiceDevPort(myServiceDefinition);
+ * ```
+ *
+ * @throws Error if no valid starting port can be found or 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 declare function mapServiceDevPort<const SpecificService extends ServiceDefinition>(service: Readonly<SpecificService>, options?: Readonly<Omit<FindPortOptions, 'isValidResponse'>>): Promise<SpecificService>;

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

@@ -0,0 +1,156 @@
+import { assert, check, waitUntil } from '@augment-vir/assert';
+import { ensureErrorAndPrependMessage, HttpMethod, wrapInTry, } from '@augment-vir/common';
+import { convertDuration } from 'date-vir';
+import { buildUrl, parseUrl } from 'url-vir';
+import { defineService } from '../service/define-service.js';
+/**
+ * This header is set on all responses handled by rest-vir so we know what service a response came
+ * from.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export const restVirServiceNameHeader = 'rest-vir-service';
+/**
+ * Use this to find a service's port number when started without a locked-in port. This allows a
+ * client (usually a website frontend) to find which port the server started on by scanning ports
+ * starting with the port defined in the service's `serviceOrigin` property.
+ *
+ * If the service has no port in its `serviceOrigin` property, this function throws an error.
+ *
+ * Note that the service given must have at least one endpoint defined for this function to work.
+ *
+ * This is used in `defineService` if the `findActiveDevPort` option is set to true.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {findDevServicePort, defineService, AnyOrigin} from '@rest-vir/define-service';
+ *
+ * const myService = defineService({
+ *     serviceName: 'my-service',
+ *     serviceOrigin: 'https://localhost:3000',
+ *     requiredClientOrigin: AnyOrigin,
+ *     endpoints: {
+ *         '/my-path': {
+ *             methods: {
+ *                 [HttpMethod.Get]: true,
+ *             },
+ *             requestDataShape: undefined,
+ *             responseDataShape: undefined,
+ *         },
+ *     },
+ * });
+ *
+ * const {origin} = await findDevServicePort(myService);
+ * ```
+ *
+ * @throws Error if no valid starting port can be found or 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 findDevServicePort(service, options = {}) {
+    try {
+        const startingOrigin = options.startingOriginOverride || service.serviceOrigin;
+        const endpoint = Object.values(service.endpoints)[0];
+        if (!endpoint) {
+            throw new Error(`Service has no endpoints.`);
+        }
+        const port = await waitUntil.isNumber(() => findLivePort(startingOrigin, endpoint.path, {
+            ...options,
+            isValidResponse(response) {
+                return (response.headers.get(restVirServiceNameHeader) === service.serviceName);
+            },
+        }), {
+            timeout: options.timeout,
+        });
+        const { origin } = buildUrl(startingOrigin, {
+            port,
+        });
+        return {
+            port,
+            origin,
+        };
+    }
+    catch (error) {
+        throw ensureErrorAndPrependMessage(error, `Cannot find dev origin for service '${service.serviceName}'`);
+    }
+}
+/**
+ * Find the first port, starting with the port in the given origin, that, with the given path, is
+ * alive and matches, if provided, `isValidResponse`.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @throws Error if no valid starting port can be found or 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 }, } = {}) {
+    const { port: originalPort } = parseUrl(originWithStartingPort);
+    if (!originalPort) {
+        throw new Error(`Given origin doesn't use a port.`);
+    }
+    const startingPort = Number(originalPort);
+    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 startTime = Date.now();
+    while (!foundValidPort) {
+        const port = findDistance + startingPort;
+        if (Date.now() - startTime >= timeoutMs) {
+            throw new Error(`Port scan timeout reached. Last scanned port: ${port - 1}`);
+        }
+        const newUrl = buildUrl(originWithStartingPort, {
+            pathname: pathToCheck,
+            port,
+        }).href;
+        const response = await wrapInTry(() => fetch(newUrl, {
+            method: HttpMethod.Options,
+        }));
+        if (!check.instanceOf(response, Error) &&
+            response.ok &&
+            (isValidResponse ? isValidResponse(response) : true)) {
+            foundValidPort = true;
+        }
+        else if (findDistance >= maxScanDistance) {
+            throw new Error(`Max port scan distance reached. Last scanned port: ${port}`);
+        }
+        else {
+            findDistance++;
+        }
+    }
+    return findDistance + startingPort;
+}
+/**
+ * Creates a copy of a service definition (without mutating the original service definition) that
+ * maps the service's origin port to find the live port that's actually running.
+ *
+ * This is useful for situations in dev where backend automatically starts on a different port if
+ * the original port is already in use.
+ *
+ * @category Client (Frontend) Connection
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {mapServiceDevPort} from '@rest-vir/define-service';
+ *
+ * const mappedService = await mapServiceDevPort(myServiceDefinition);
+ * ```
+ *
+ * @throws Error if no valid starting port can be found or 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 mapServiceDevPort(service, options = {}) {
+    const { origin } = await findDevServicePort(service, options);
+    return defineService({
+        ...service.init,
+        serviceOrigin: origin,
+    });
+}

package/dist/endpoint/endpoint-path.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Extracts all path parameters from an endpoint path.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type PathParams<EndpointPath extends string> = string extends EndpointPath ? Record<string, string> : EndpointPath extends `${string}:${infer Param}/${infer Rest}` ? Param | PathParams<`/${Rest}`> : EndpointPath extends `${string}:${infer Param}` ? Param : never;
+/**
+ * Base requirement for endpoint paths.
+ *
+ * Note that this whole thing should be lowercase. Technically, we should use `Lowercase<string>`
+ * because of that. However, that makes the type requirements way too strict and hard to deal with.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type EndpointPathBase = `/${string}` | '/';
+/**
+ * Asserts that the given endpoint or WebSocket path 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 assertValidEndpointPath(path: string): void;

package/dist/endpoint/endpoint-path.js

@@ -0,0 +1,14 @@
+import { assert } from '@augment-vir/assert';
+/**
+ * Asserts that the given endpoint or WebSocket path 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 assertValidEndpointPath(path) {
+    if (path !== '/') {
+        assert.startsWith(path, '/', 'Path does not start with /');
+        assert.endsWithout(path, '/', 'Path cannot end with /');
+    }
+}