@rest-vir/implement-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,49 @@
+# @rest-vir/implement-service
+
+Part of the rest-vir suite. This package is used for implementing a REST service already defined by [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service).
+
+See the full docs at https://electrovir.github.io/rest-vir
+
+## Installation
+
+```sh
+npm i @rest-vir/implement-service
+```
+
+## Usage
+
+Implement your service:
+
+```TypeScript
+import {HttpStatus, implementService} from '@rest-vir/implement-service';
+
+export const myServiceImplementation = implementService(
+    {
+        service: myServiceDefinition,
+    },
+    {
+        endpoints: {
+            '/my-endpoint'() {
+                return {
+                    statusCode: HttpStatus.Ok,
+                };
+            },
+            async '/my-endpoint/:user-id'({pathParams}) {
+                const user = await readUserFromDatabase(pathParams['user-id']);
+
+                return {
+                    statusCode: HttpStatus.Ok,
+                    responseData: user,
+                };
+            },
+        },
+        webSockets: {
+            '/my-web-socket': {
+                onMessage({webSocket}) {
+                    webSocket.send('hi!');
+                },
+            },
+        },
+    },
+);
+```

package/dist/implementation/generic-service-implementation.d.ts

@@ -0,0 +1,44 @@
+import { type Overwrite } from '@augment-vir/common';
+import { EndpointDefinition, EndpointPathBase, ServiceDefinition, WebSocketDefinition, type GenericEndpointDefinition, type GenericWebSocketDefinition, type NoParam } from '@rest-vir/define-service';
+import { type ServiceLogger } from '../util/service-logger.js';
+import { type EndpointImplementation } from './implement-endpoint.js';
+import { type WebSocketImplementation } from './implement-web-socket.js';
+import { type ContextInit } from './service-context-init.js';
+/**
+ * A fully implemented endpoint.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ImplementedEndpoint<Context = any, ServiceName extends string = any, SpecificEndpoint extends EndpointDefinition = GenericEndpointDefinition> = Overwrite<SpecificEndpoint, {
+    service: GenericServiceImplementation;
+}> & {
+    implementation: EndpointImplementation<Context, ServiceName>;
+};
+/**
+ * A super generic service implementation that be assigned to from any concrete service
+ * implementation.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type GenericServiceImplementation = Omit<ServiceDefinition, 'endpoints' | 'webSockets'> & {
+    endpoints: Record<EndpointPathBase, any>;
+    webSockets: Record<EndpointPathBase, ImplementedWebSocket>;
+    createContext: ContextInit<any, any, any, any> | undefined;
+    logger: ServiceLogger;
+};
+/**
+ * A fully implemented WebSocket.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ImplementedWebSocket<Context = any, ServiceName extends string = any, SpecificWebSocket extends WebSocketDefinition | NoParam = NoParam> = Overwrite<SpecificWebSocket extends NoParam ? GenericWebSocketDefinition : SpecificWebSocket, {
+    service: GenericServiceImplementation;
+}> & {
+    implementation: WebSocketImplementation<Context, ServiceName, SpecificWebSocket>;
+};

package/dist/implementation/generic-service-implementation.js

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

package/dist/implementation/implement-endpoint.d.ts

@@ -0,0 +1,113 @@
+import { ErrorHttpStatusCategories, ExtractKeysWithMatchingValues, HttpMethod, HttpStatusByCategory, MaybePromise, SuccessHttpStatusCategories } from '@augment-vir/common';
+import { BaseSearchParams, BaseServiceEndpointsInit, EndpointDefinition, EndpointInit, EndpointPathBase, MinimalService, NoParam, ServiceDefinition, WithFinalEndpointProps, type PathParams } from '@rest-vir/define-service';
+import { type IncomingHttpHeaders, type OutgoingHttpHeaders } from 'node:http';
+import { type IsEqual, type IsNever } from 'type-fest';
+import { ServerRequest, type ServerResponse } from '../util/data.js';
+import { type ServiceLogger } from '../util/service-logger.js';
+/**
+ * The part of {@link EndpointImplementationOutput} allowed for error responses.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type EndpointImplementationErrorOutput = {
+    statusCode: HttpStatusByCategory<ErrorHttpStatusCategories>;
+    /**
+     * An error message which will get sent to the frontend.
+     *
+     * DO NOT INCLUDE SENSITIVE INFORMATION IN HERE.
+     */
+    responseErrorMessage?: string | undefined;
+    responseData?: undefined;
+    headers?: OutgoingHttpHeaders | undefined;
+    dataType?: undefined;
+};
+/**
+ * The object that all endpoint implementations should return.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type EndpointImplementationOutput<ResponseDataType = unknown> = EndpointImplementationErrorOutput | ({
+    statusCode: HttpStatusByCategory<SuccessHttpStatusCategories>;
+    responseErrorMessage?: never;
+    /**
+     * Set the response data type. If any response data is included, the default is
+     * `application/json`.
+     */
+    dataType?: string | undefined;
+    headers?: OutgoingHttpHeaders | undefined;
+} & (ResponseDataType extends undefined ? {
+    responseData?: ResponseDataType;
+} : {
+    responseData: ResponseDataType;
+}));
+/**
+ * The object that all endpoint implementations receive as an input.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type EndpointImplementationParams<Context = any, ServiceName extends string = any, SpecificEndpoint extends EndpointDefinition | NoParam = NoParam> = {
+    pathParams: SpecificEndpoint extends NoParam ? Readonly<Record<string, string>> : PathParams<Exclude<SpecificEndpoint, NoParam>['path']> extends string ? Readonly<Record<PathParams<Exclude<SpecificEndpoint, NoParam>['path']>, string>> : Readonly<Record<string, string>>;
+    context: Context;
+    method: IsEqual<Extract<SpecificEndpoint, NoParam>, NoParam> extends true ? HttpMethod : ExtractKeysWithMatchingValues<Exclude<SpecificEndpoint, NoParam>['methods'], true> extends infer AvailableMethod ? IsNever<AvailableMethod> extends true ? HttpMethod : AvailableMethod : never;
+    endpoint: IsEqual<Extract<SpecificEndpoint, NoParam>, NoParam> extends true ? EndpointDefinition : SpecificEndpoint;
+    service: MinimalService<ServiceName>;
+    requestHeaders: IncomingHttpHeaders;
+    requestData: IsEqual<Extract<SpecificEndpoint, NoParam>, NoParam> extends true ? any : WithFinalEndpointProps<Exclude<SpecificEndpoint, NoParam>, any>['RequestType'];
+    request: ServerRequest;
+    response: ServerResponse;
+    log: Readonly<ServiceLogger>;
+    searchParams: SpecificEndpoint extends NoParam ? BaseSearchParams : Exclude<SpecificEndpoint, NoParam>['SearchParamsType'];
+};
+/**
+ * Generic parameters for {@link EndpointImplementation} that should be compatible with _any_
+ * endpoint implementation.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type GenericEndpointImplementationParams = {
+    context: any;
+    method: any;
+    endpoint: any;
+    service: MinimalService<any>;
+    requestHeaders: IncomingHttpHeaders;
+    searchParams: BaseSearchParams;
+    pathParams: Readonly<Record<string, string>>;
+    requestData: any;
+    request: ServerRequest;
+    response: ServerResponse;
+    log: Readonly<ServiceLogger>;
+};
+/**
+ * A full, type-safe endpoint implementation type.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type EndpointImplementation<Context = any, ServiceName extends string = any, SpecificEndpoint extends EndpointDefinition | NoParam = NoParam> = IsEqual<Extract<SpecificEndpoint, NoParam>, NoParam> extends true ? (params: GenericEndpointImplementationParams) => any : (params: Readonly<EndpointImplementationParams<Context, ServiceName, SpecificEndpoint>>) => MaybePromise<EndpointImplementationOutput<WithFinalEndpointProps<SpecificEndpoint, any>['ResponseType']>>;
+/**
+ * All endpoint implementations to match the service definition's endpoints.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type EndpointImplementations<Context = any, ServiceName extends string = any, EndpointsInit extends BaseServiceEndpointsInit | NoParam = NoParam> = EndpointsInit extends NoParam ? Record<EndpointPathBase, EndpointImplementation> : {
+    [EndpointPath in keyof EndpointsInit]: EndpointsInit[EndpointPath] extends EndpointInit ? EndpointPath extends EndpointPathBase ? EndpointImplementation<Context, ServiceName, WithFinalEndpointProps<EndpointsInit[EndpointPath], EndpointPath>> : never : never;
+};
+/**
+ * Asserts that all endpoint implementations are valid.
+ *
+ * @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 assertValidEndpointImplementations(service: Readonly<Pick<ServiceDefinition, 'endpoints' | 'serviceName'>>, endpointImplementations: EndpointImplementations): asserts endpointImplementations is Record<EndpointPathBase, EndpointImplementation>;

package/dist/implementation/implement-endpoint.js

@@ -0,0 +1,56 @@
+import { check } from '@augment-vir/assert';
+import { getObjectTypedEntries, } from '@augment-vir/common';
+import { ServiceDefinitionError, } from '@rest-vir/define-service';
+/**
+ * Asserts that all endpoint implementations are valid.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export function assertValidEndpointImplementations(service, endpointImplementations) {
+    const nonFunctionImplementations = getObjectTypedEntries(endpointImplementations).filter(([, implementation,]) => {
+        return check.isNotFunction(implementation);
+    });
+    if (nonFunctionImplementations.length) {
+        throw new ServiceDefinitionError({
+            path: undefined,
+            errorMessage: `Endpoint implementations are not functions for endpoints: '${nonFunctionImplementations
+                .map(([endpointPath]) => endpointPath)
+                .join(',')}'`,
+            serviceName: service.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+    const missingEndpointImplementationPaths = [];
+    const extraEndpointImplementationPaths = [];
+    Object.keys(service.endpoints).forEach((key) => {
+        if (!(key in endpointImplementations)) {
+            missingEndpointImplementationPaths.push(key);
+        }
+    });
+    Object.keys(endpointImplementations).forEach((key) => {
+        if (!(key in service.endpoints)) {
+            extraEndpointImplementationPaths.push(key);
+        }
+    });
+    if (missingEndpointImplementationPaths.length) {
+        throw new ServiceDefinitionError({
+            path: undefined,
+            errorMessage: `Endpoints are missing implementations: '${missingEndpointImplementationPaths.join(',')}'`,
+            serviceName: service.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+    if (extraEndpointImplementationPaths.length) {
+        throw new ServiceDefinitionError({
+            path: undefined,
+            errorMessage: `Endpoint implementations have extra endpoints: '${extraEndpointImplementationPaths.join(',')}'`,
+            serviceName: service.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+}

package/dist/implementation/implement-service.d.ts

@@ -0,0 +1,91 @@
+import { type KeyCount, type MaybePromise } from '@augment-vir/common';
+import { BaseServiceEndpointsInit, EndpointPathBase, NoParam, ServiceDefinition, type BaseServiceWebSocketsInit } from '@rest-vir/define-service';
+import { type IsEqual, type OmitIndexSignature } from 'type-fest';
+import { ServiceLoggerOption, type ServiceLogger } from '../util/service-logger.js';
+import { type ImplementedEndpoint, type ImplementedWebSocket } from './generic-service-implementation.js';
+import { type EndpointImplementations } from './implement-endpoint.js';
+import { WebSocketImplementations } from './implement-web-socket.js';
+import { type ContextInit } from './service-context-init.js';
+/**
+ * A user-defined endpoint error handler for service (and its endpoints) errors.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type CustomErrorHandler = (error: Error) => MaybePromise<void>;
+/**
+ * Type-safe input for {@link implementService}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServiceImplementationInit<Context, ServiceName extends string, EndpointsInit extends BaseServiceEndpointsInit, WebSocketsInit extends BaseServiceWebSocketsInit> = {
+    service: ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>;
+    /**
+     * Logger for the service. Use {@link silentServiceLogger} to disable logging entirely (even
+     * errors) or simply set `undefined` to the log type that you wish to suppress. An omitted log
+     * keys will fallback to the efault logger.
+     */
+    logger?: ServiceLoggerOption;
+} & (IsEqual<Context, undefined> extends true ? {
+    createContext?: undefined | ContextInit<Context, NoInfer<ServiceName>, NoInfer<EndpointsInit>, NoInfer<WebSocketsInit>>;
+} : {
+    createContext: ContextInit<Context, NoInfer<ServiceName>, NoInfer<EndpointsInit>, NoInfer<WebSocketsInit>>;
+});
+/**
+ * Parameters for implementations for {@link implementService}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServiceImplementationsParams<Context, ServiceName extends string, EndpointsInit extends BaseServiceEndpointsInit, WebSocketsInit extends BaseServiceWebSocketsInit> = (KeyCount<OmitIndexSignature<EndpointsInit>> extends 0 ? {
+    endpoints?: never;
+} : {
+    endpoints: EndpointImplementations<NoInfer<Context>, NoInfer<ServiceName>, NoInfer<EndpointsInit>>;
+}) & (KeyCount<OmitIndexSignature<WebSocketsInit>> extends 0 ? {
+    webSockets?: never;
+} : {
+    webSockets: WebSocketImplementations<NoInfer<Context>, NoInfer<ServiceName>, NoInfer<WebSocketsInit>>;
+});
+/**
+ * Creates an implemented service that is fully ready to be run as a server by attaching endpoint
+ * implementations to the given {@link ServiceDefinition}.
+ *
+ * This can _only_ be run in backend code.
+ *
+ * @category Implement Service
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export declare function implementService<const ServiceName extends string, const EndpointsInit extends BaseServiceEndpointsInit, const WebSocketsInit extends BaseServiceWebSocketsInit, const Context = undefined>(
+/** Init must be first so that TypeScript can infer the type for `Context`. */
+{ service, createContext, logger, }: ServiceImplementationInit<Context, ServiceName, EndpointsInit, WebSocketsInit>, { endpoints: endpointImplementations, webSockets: webSocketImplementations, }: ServiceImplementationsParams<NoInfer<Context>, NoInfer<ServiceName>, NoInfer<EndpointsInit>, NoInfer<WebSocketsInit>>): ServiceImplementation<Context, ServiceName, EndpointsInit, WebSocketsInit>;
+/**
+ * A finalized service implementation created by {@link implementService}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServiceImplementation<Context = any, ServiceName extends string = any, EndpointsInit extends BaseServiceEndpointsInit | NoParam = NoParam, WebSocketsInit extends BaseServiceWebSocketsInit | NoParam = NoParam> = Omit<ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>, 'endpoints' | 'webSockets'> & {
+    endpoints: {
+        [EndpointPath in keyof ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>['endpoints']]: EndpointPath extends EndpointPathBase ? ImplementedEndpoint<Context, ServiceName, ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>['endpoints'][EndpointPath]> : never;
+    };
+    webSockets: {
+        [WebSocketPath in keyof ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>['webSockets']]: WebSocketPath extends EndpointPathBase ? ImplementedWebSocket<Context, ServiceName, ServiceDefinition<ServiceName, EndpointsInit, WebSocketsInit>['webSockets'][WebSocketPath]> : never;
+    };
+    createContext: ContextInit<Context, ServiceName, EndpointsInit, WebSocketsInit> | undefined;
+    logger: ServiceLogger;
+};
+/**
+ * A type util that converts a {@link ServiceDefinition} instance type into its companion
+ * {@link ServiceImplementation} type.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServiceImplementationFromServiceDefinition<SpecificServiceDefinition extends ServiceDefinition> = SpecificServiceDefinition extends ServiceDefinition<infer ServiceName, infer EndpointInit, infer WebSocketInit> ? ServiceImplementation<unknown, ServiceName, EndpointInit, WebSocketInit> : 'ERROR: Failed to infer service definition type parameters';

package/dist/implementation/implement-service.js

@@ -0,0 +1,63 @@
+import { assert } from '@augment-vir/assert';
+import { mapObjectValues, } from '@augment-vir/common';
+import { createServiceLogger, } from '../util/service-logger.js';
+import { assertValidEndpointImplementations, } from './implement-endpoint.js';
+import { assertValidWebSocketImplementations, } from './implement-web-socket.js';
+/**
+ * Creates an implemented service that is fully ready to be run as a server by attaching endpoint
+ * implementations to the given {@link ServiceDefinition}.
+ *
+ * This can _only_ be run in backend code.
+ *
+ * @category Implement Service
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export function implementService(
+/** Init must be first so that TypeScript can infer the type for `Context`. */
+{ service, createContext, logger, }, { endpoints: endpointImplementations, webSockets: webSocketImplementations, }) {
+    assertValidEndpointImplementations(service, endpointImplementations || {});
+    assertValidWebSocketImplementations(service, webSocketImplementations || {});
+    const endpoints = mapObjectValues(service.endpoints, (endpointPath, endpoint) => {
+        const implementation = endpointImplementations?.[endpointPath];
+        assert.isDefined(implementation);
+        assert.isNotString(implementation);
+        /**
+         * Note: this return object is actually wrong. The service property will not be correct as
+         * the `endpoint` here only has the minimal service. Below, after `serviceImplementation` is
+         * created, we attach the correct service to all endpoints.
+         */
+        return {
+            ...endpoint,
+            implementation,
+        };
+    });
+    const webSockets = mapObjectValues(service.webSockets, (webSocketPath, webSocketImplementation) => {
+        const implementation = webSocketImplementations?.[webSocketPath];
+        assert.isDefined(implementation);
+        assert.isNotString(webSocketImplementation);
+        /**
+         * Note: this return object is actually wrong. The service property will not be correct
+         * as the WebSocket here only has the minimal service. Below, after
+         * `serviceImplementation` is created, we attach the correct service to all WebSockets.
+         */
+        return {
+            ...webSocketImplementation,
+            implementation,
+        };
+    });
+    const serviceImplementation = {
+        ...service,
+        endpoints,
+        webSockets,
+        createContext,
+        logger: createServiceLogger(logger),
+    };
+    Object.values(endpoints).forEach((endpoint) => {
+        endpoint.service = serviceImplementation;
+    });
+    Object.values(webSockets).forEach((webSocket) => {
+        webSocket.service = serviceImplementation;
+    });
+    return serviceImplementation;
+}

package/dist/implementation/implement-web-socket.d.ts

@@ -0,0 +1,67 @@
+import { type MaybePromise } from '@augment-vir/common';
+import { BaseSearchParams, BaseServiceWebSocketsInit, EndpointPathBase, MinimalService, NoParam, ServiceDefinition, WebSocketDefinition, WebSocketInit, WithFinalWebSocketProps } from '@rest-vir/define-service';
+import { type IncomingHttpHeaders } from 'node:http';
+import { type IsEqual } from 'type-fest';
+import { type ServerRequest, type ServerWebSocket } from '../util/data.js';
+import { type ServiceLogger } from '../util/service-logger.js';
+/**
+ * A WebSocket implementation, with callbacks for WebSocket events.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type WebSocketImplementation<Context = any, ServiceName extends string = any, SpecificWebSocket extends WebSocketDefinition | NoParam = NoParam> = SpecificWebSocket extends NoParam ? any : Partial<{
+    /** This will be called when the WebSocket is connected and created. */
+    onConnection: (params: WebSocketImplementationParams<Context, ServiceName, SpecificWebSocket, false>) => MaybePromise<void>;
+    /**
+     * This will be called on every received WebSocket message.
+     *
+     * @see https://github.com/websockets/ws/blob/HEAD/doc/ws.md#event-message
+     */
+    onMessage: (params: WebSocketImplementationParams<Context, ServiceName, SpecificWebSocket, true>) => MaybePromise<void>;
+    /**
+     * This will be called when the WebSocket is closed.
+     *
+     * @see https://github.com/websockets/ws/blob/HEAD/doc/ws.md#event-close-1
+     */
+    onClose: (params: WebSocketImplementationParams<Context, ServiceName, SpecificWebSocket, false>) => MaybePromise<void>;
+}>;
+/**
+ * Parameters for event callbacks in {@link WebSocketImplementation}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type WebSocketImplementationParams<Context = any, ServiceName extends string = any, SpecificWebSocket extends WebSocketDefinition | NoParam = NoParam, WithMessage extends boolean = boolean> = {
+    context: Context;
+    webSocket: ServerWebSocket<SpecificWebSocket>;
+    webSocketDefinition: IsEqual<Extract<SpecificWebSocket, NoParam>, NoParam> extends true ? WebSocketDefinition : SpecificWebSocket;
+    log: Readonly<ServiceLogger>;
+    service: MinimalService<ServiceName>;
+    headers: IncomingHttpHeaders;
+    request: ServerRequest;
+    protocols: SpecificWebSocket extends NoParam ? string[] : Exclude<SpecificWebSocket, NoParam>['ProtocolsType'];
+    searchParams: SpecificWebSocket extends NoParam ? BaseSearchParams : Exclude<SpecificWebSocket, NoParam>['SearchParamsType'];
+} & (IsEqual<WithMessage, true> extends true ? {
+    message: SpecificWebSocket extends NoParam ? any : Exclude<SpecificWebSocket, NoParam>['MessageFromClientType'];
+} : unknown);
+/**
+ * All WebSockets implementations to match the service definition's WebSockets.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type WebSocketImplementations<Context = any, ServiceName extends string = any, WebSocketsInit extends BaseServiceWebSocketsInit | NoParam = NoParam> = WebSocketsInit extends NoParam ? Record<EndpointPathBase, WebSocketImplementation> : {
+    [WebSocketPath in keyof WebSocketsInit]: WebSocketsInit[WebSocketPath] extends WebSocketInit ? WebSocketPath extends EndpointPathBase ? WebSocketImplementation<Context, ServiceName, WithFinalWebSocketProps<WebSocketsInit[WebSocketPath], WebSocketPath>> : never : never;
+};
+/**
+ * Asserts that all WebSocket implementations are valid.
+ *
+ * @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 assertValidWebSocketImplementations(service: Pick<ServiceDefinition, 'webSockets' | 'serviceName'>, webSocketImplementations: WebSocketImplementations): void;

package/dist/implementation/implement-web-socket.js

@@ -0,0 +1,72 @@
+import { check } from '@augment-vir/assert';
+import { filterMap, getObjectTypedEntries, getObjectTypedKeys, } from '@augment-vir/common';
+import { ServiceDefinitionError, } from '@rest-vir/define-service';
+/**
+ * Asserts that all WebSocket implementations are valid.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export function assertValidWebSocketImplementations(service, webSocketImplementations) {
+    const nonFunctionImplementations = filterMap(getObjectTypedEntries(webSocketImplementations), ([webSocketPath, webSocketImplementation,]) => {
+        const nonFunctionKeys = getObjectTypedKeys(webSocketImplementation).filter((key) => {
+            const callback = webSocketImplementation[key];
+            return callback && check.isNotFunction(callback);
+        });
+        if (nonFunctionKeys.length) {
+            return {
+                path: webSocketPath,
+                nonFunctionKeys,
+            };
+        }
+        else {
+            return undefined;
+        }
+    }, check.isTruthy);
+    if (nonFunctionImplementations.length) {
+        const invalidFunctionsString = nonFunctionImplementations
+            .map(({ nonFunctionKeys, path }) => [
+            path,
+            nonFunctionKeys.join(','),
+        ].join(': '))
+            .join(';\n');
+        throw new ServiceDefinitionError({
+            path: undefined,
+            errorMessage: `WebSockets implementations are not functions for:\n${invalidFunctionsString}`,
+            serviceName: service.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+    const missingImplementationPaths = [];
+    const extraImplementationPaths = [];
+    Object.keys(service.webSockets).forEach((key) => {
+        if (!(key in webSocketImplementations)) {
+            missingImplementationPaths.push(key);
+        }
+    });
+    Object.keys(webSocketImplementations).forEach((key) => {
+        if (!(key in service.webSockets)) {
+            extraImplementationPaths.push(key);
+        }
+    });
+    if (missingImplementationPaths.length) {
+        throw new ServiceDefinitionError({
+            path: undefined,
+            errorMessage: `WebSockets are missing implementations: '${missingImplementationPaths.join(',')}'`,
+            serviceName: service.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+    if (extraImplementationPaths.length) {
+        throw new ServiceDefinitionError({
+            path: undefined,
+            errorMessage: `WebSocket implementations have extra paths: '${extraImplementationPaths.join(',')}'`,
+            serviceName: service.serviceName,
+            isEndpoint: undefined,
+            isWebSocket: undefined,
+        });
+    }
+}

package/dist/implementation/service-context-init.d.ts

@@ -0,0 +1,39 @@
+import { HttpMethod, MaybePromise, Values } from '@augment-vir/common';
+import { type BaseServiceEndpointsInit, type BaseServiceWebSocketsInit, type EndpointDefinition, type EndpointPathBase, type MinimalService, type NoParam, type WebSocketDefinition, type WithFinalEndpointProps, type WithFinalWebSocketProps } from '@rest-vir/define-service';
+import { type IncomingHttpHeaders } from 'node:http';
+import { type RequireExactlyOne } from 'type-fest';
+import { type ServerRequest, type ServerResponse } from '../util/data.js';
+import { EndpointImplementationErrorOutput } from './implement-endpoint.js';
+/**
+ * User-defined service implementation Context generator.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ContextInit<Context, ServiceName extends string, EndpointsInit extends BaseServiceEndpointsInit | NoParam, WebSocketsInit extends BaseServiceWebSocketsInit | NoParam> = (params: Readonly<ContextInitParameters<ServiceName, EndpointsInit, WebSocketsInit>>) => MaybePromise<RequireExactlyOne<{
+    /** The context created for this request. */
+    context: Context;
+    /**
+     * Instead of creating a context object for the current request, instead, reject the request
+     * with the specified status code and other options.
+     */
+    reject: EndpointImplementationErrorOutput;
+}>>;
+/**
+ * Parameters for {@link ContextInit}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ContextInitParameters<ServiceName extends string = any, EndpointsInit extends BaseServiceEndpointsInit | NoParam = NoParam, WebSocketsInit extends BaseServiceWebSocketsInit | NoParam = NoParam> = {
+    service: MinimalService<ServiceName>;
+    requestHeaders: IncomingHttpHeaders;
+    method: HttpMethod;
+    requestData: EndpointsInit extends NoParam ? unknown : WithFinalEndpointProps<Values<EndpointsInit>, Extract<keyof EndpointsInit, EndpointPathBase>>['RequestType'];
+    request: ServerRequest;
+    response: ServerResponse;
+    endpointDefinition?: (EndpointsInit extends NoParam ? EndpointDefinition : WithFinalEndpointProps<Values<EndpointsInit>, Extract<keyof EndpointsInit, EndpointPathBase>>) | undefined;
+    webSocketDefinition?: (WebSocketsInit extends NoParam ? WebSocketDefinition : WithFinalWebSocketProps<Values<WebSocketsInit>, Extract<keyof WebSocketsInit, EndpointPathBase>>) | undefined;
+};

package/dist/implementation/service-context-init.js

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

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { HttpMethod, HttpStatus } from '@augment-vir/common';
+export * from './implementation/generic-service-implementation.js';
+export * from './implementation/implement-endpoint.js';
+export * from './implementation/implement-service.js';
+export * from './implementation/implement-web-socket.js';
+export * from './implementation/service-context-init.js';
+export * from './util/data.js';
+export * from './util/handler.error.js';
+export * from './util/service-logger.js';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { HttpMethod, HttpStatus } from '@augment-vir/common';
+export * from './implementation/generic-service-implementation.js';
+export * from './implementation/implement-endpoint.js';
+export * from './implementation/implement-service.js';
+export * from './implementation/implement-web-socket.js';
+export * from './implementation/service-context-init.js';
+export * from './util/data.js';
+export * from './util/handler.error.js';
+export * from './util/service-logger.js';

package/dist/util/data.d.ts

@@ -0,0 +1,30 @@
+import { type NoParam, type OverwriteWebSocketMethods, type WebSocketDefinition, type WebSocketLocation } from '@rest-vir/define-service';
+import { type FastifyReply, type FastifyRequest } from 'fastify';
+import { type WebSocket as WsWebSocket } from 'ws';
+/**
+ * A type alias for the request objects used by rest-vir. Currently this is the `FastifyRequest`
+ * object from Fastify.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServerRequest = FastifyRequest;
+/**
+ * A type alias for the response objects used by rest-vir. Currently this is the `FastifyReply`
+ * object from Fastify.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServerResponse = FastifyReply;
+/**
+ * A type alias for the WebSocket objects used by rest-vir. Currently this is the `WebSocket` object
+ * from the ws package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServerWebSocket<SpecificWebSocket extends WebSocketDefinition | NoParam> = OverwriteWebSocketMethods<WsWebSocket, WebSocketLocation.OnHost, SpecificWebSocket>;

package/dist/util/data.js

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

package/dist/util/handler.error.d.ts

@@ -0,0 +1,30 @@
+/**
+ * An error thrown internally from rest-vir while handling an request. This will not include errors
+ * thrown by an endpoint or WebSocket implementation itself.
+ *
+ * The default service logger will only log the message of these errors, not the whole stack track
+ * (so logs are easier to read).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export declare class RestVirHandlerError extends Error {
+    readonly name = "RestVirHandlerError";
+    constructor(route: Parameters<typeof createRestVirHandlerErrorPrefix>[0], message: string);
+}
+/**
+ * Creates the handler error string used by {@link RestVirHandlerError}.
+ *
+ * @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 createRestVirHandlerErrorPrefix(route: Readonly<{
+    path: string;
+    service: {
+        serviceName: string;
+    };
+    isWebSocket: boolean | undefined;
+    isEndpoint: boolean | undefined;
+}>): string;

package/dist/util/handler.error.js

@@ -0,0 +1,29 @@
+import { combineErrorMessages } from '@augment-vir/common';
+/**
+ * An error thrown internally from rest-vir while handling an request. This will not include errors
+ * thrown by an endpoint or WebSocket implementation itself.
+ *
+ * The default service logger will only log the message of these errors, not the whole stack track
+ * (so logs are easier to read).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export class RestVirHandlerError extends Error {
+    name = 'RestVirHandlerError';
+    constructor(route, message) {
+        super(combineErrorMessages(createRestVirHandlerErrorPrefix(route), message));
+    }
+}
+/**
+ * Creates the handler error string used by {@link RestVirHandlerError}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export function createRestVirHandlerErrorPrefix(route) {
+    const routeNoun = route.isWebSocket ? 'WebSocket ' : route.isEndpoint ? 'Endpoint ' : '';
+    return `${routeNoun}'${route.path}' failed in service '${route.service.serviceName}'`;
+}

package/dist/util/service-logger.d.ts

@@ -0,0 +1,52 @@
+import { type PartialWithUndefined } from '@augment-vir/common';
+/**
+ * A service logger. All internal service logs will go through this and endpoint implementations are
+ * also given the service's logger to use if they wish.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServiceLogger = {
+    /** The error log is always guaranteed to be passed exactly a single error. */
+    error: (error: Error) => void;
+    /**
+     * The info log maybe receive any number of arguments of any type. Note that
+     * {@link defaultServiceLogger} already contains logic to convert these into strings so you may
+     * want to utilize its behavior in your custom logging.
+     */
+    info: (...args: ReadonlyArray<unknown>) => void;
+};
+/**
+ * User-definable service logger. Loggers may be set as `undefined` here to silence them.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export type ServiceLoggerOption = PartialWithUndefined<ServiceLogger>;
+/**
+ * The efault service logger.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export declare const defaultServiceLogger: ServiceLogger;
+/**
+ * Combines a user defined service logger with the default logger, silencing loggers that have been
+ * set to `undefined` by the user.
+ *
+ * @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 createServiceLogger(option?: ServiceLoggerOption): ServiceLogger;
+/**
+ * A silent service logger. All logs simply do not get logged or do anything at all.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export declare const silentServiceLogger: ServiceLogger;

package/dist/util/service-logger.js

@@ -0,0 +1,43 @@
+import { log, mapObjectValues } from '@augment-vir/common';
+/**
+ * The efault service logger.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export const defaultServiceLogger = {
+    error(error) {
+        log.error(error);
+    },
+    info: log.faint,
+};
+/**
+ * Combines a user defined service logger with the default logger, silencing loggers that have been
+ * set to `undefined` by the user.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export function createServiceLogger(option = {}) {
+    return mapObjectValues(defaultServiceLogger, (logKey, defaultLogFunction) => {
+        if (logKey in option) {
+            return option[logKey] || silentServiceLogger[logKey];
+        }
+        else {
+            return defaultLogFunction;
+        }
+    });
+}
+/**
+ * A silent service logger. All logs simply do not get logged or do anything at all.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/implement-service
+ * @package [`@rest-vir/implement-service`](https://www.npmjs.com/package/@rest-vir/implement-service)
+ */
+export const silentServiceLogger = {
+    error: () => { },
+    info: () => { },
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "@rest-vir/implement-service",
+    "version": "0.0.2",
+    "description": "Implement a service defined by @rest-vir/define-service.",
+    "keywords": [
+        "rest",
+        "api",
+        "express",
+        "service",
+        "backend",
+        "server",
+        "websocket",
+        "vir"
+    ],
+    "homepage": "https://github.com/electrovir/rest-vir",
+    "bugs": {
+        "url": "https://github.com/electrovir/rest-vir/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/electrovir/rest-vir.git"
+    },
+    "license": "(MIT or CC0 1.0)",
+    "author": {
+        "name": "electrovir",
+        "url": "https://github.com/electrovir"
+    },
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "compile": "virmator compile",
+        "docs": "md-code README.md",
+        "start": "tsx src/index.ts",
+        "test": "virmator test node",
+        "test:coverage": "npm run test coverage",
+        "test:docs": "npm run docs check",
+        "test:update": "npm test update"
+    },
+    "dependencies": {
+        "@augment-vir/assert": "^31.9.1",
+        "@augment-vir/common": "^31.9.1",
+        "@rest-vir/define-service": "^0.0.2",
+        "@types/ws": "^8.5.14",
+        "fastify": "^5.2.1",
+        "object-shape-tester": "^5.1.1",
+        "path-to-regexp": "^8.2.0",
+        "type-fest": "^4.35.0"
+    },
+    "devDependencies": {
+        "@augment-vir/test": "^31.9.1",
+        "@types/node": "^22.13.4",
+        "c8": "^10.1.3",
+        "istanbul-smart-text-reporter": "^1.1.5",
+        "markdown-code-example-inserter": "^3.0.3"
+    },
+    "engines": {
+        "node": ">=22"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}