graphql-http 1.6.0 → 1.7.0

package/lib/client.d.mts

@@ -0,0 +1,155 @@
+/**
+ *
+ * client
+ *
+ */
+import type { ExecutionResult } from 'graphql';
+import { RequestParams, Sink } from './common';
+/** This file is the entry point for browsers, re-export common elements. */
+export * from './common';
+/** @category Client */
+export interface ClientOptions {
+    /**
+     * URL of the GraphQL over HTTP server to connect.
+     *
+     * If the option is a function, it will be called on each request.
+     * Returning a Promise is supported too and the request will stall until it
+     * resolves.
+     *
+     * A good use-case for having a function is when using the URL for authentication,
+     * where subsequent requests (due to auth) may have a refreshed identity token.
+     *
+     * Function receives the request params. Useful for example, to ease up debugging and DevTools
+     * navigation you might want to use the operation name in the URL's search params (`/graphql?MyQuery`).
+     */
+    url: string | ((request: RequestParams) => Promise<string> | string);
+    /**
+     * Indicates whether the user agent should send cookies from the other domain in the case
+     * of cross-origin requests.
+     *
+     * Possible options are:
+     *   - `omit`: Never send or receive cookies.
+     *   - `same-origin`: Send user credentials (cookies, basic http auth, etc..) if the URL is on the same origin as the calling script.
+     *   - `include`: Always send user credentials (cookies, basic http auth, etc..), even for cross-origin calls.
+     *
+     * @default same-origin
+     */
+    credentials?: 'omit' | 'same-origin' | 'include';
+    /**
+     * A string specifying the referrer of the request. This can be a same-origin URL, about:client, or an empty string.
+     *
+     * @default undefined
+     */
+    referrer?: string;
+    /**
+     * Specifies the referrer policy to use for the request.
+     *
+     * Possible options are:
+     *   - `no-referrer`: Does not send referrer information along with requests to any origin.
+     *   - `no-referrer-when-downgrade`: Sends full referrerURL for requests: whose referrerURL and current URL are both potentially trustworthy URLs, or whose referrerURL is a non-potentially trustworthy URL.
+     *   - `same-origin`: Sends full referrerURL as referrer information when making same-origin-referrer requests.
+     *   - `origin`: Sends only the ASCII serialization of the request’s referrerURL when making both same-origin-referrer requests and cross-origin-referrer requests.
+     *   - `strict-origin`: Sends the ASCII serialization of the origin of the referrerURL for requests: whose referrerURL and current URL are both potentially trustworthy URLs, or whose referrerURL is a non-potentially trustworthy URL
+     *   - `origin-when-cross-origin`: Sends full referrerURL when making same-origin-referrer requests, and only the ASCII serialization of the origin of the request’s referrerURL is sent when making cross-origin-referrer requests
+     *   - `strict-origin-when-cross-origin`: Sends full referrerURL when making same-origin-referrer requests, and only the ASCII serialization of the origin of the request’s referrerURL when making cross-origin-referrer requests: whose referrerURL and current URL are both potentially trustworthy URLs, or whose referrerURL is a non-potentially trustworthy URL.
+     *   - `unsafe-url`: Sends full referrerURL along for both same-origin-referrer requests and cross-origin-referrer requests.
+     *
+     * @default undefined
+     */
+    referrerPolicy?: 'no-referrer' | 'no-referrer-when-downgrade' | 'same-origin' | 'origin' | 'strict-origin' | 'origin-when-cross-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+    /**
+     * HTTP headers to pass along the request.
+     *
+     * If the option is a function, it will be called on each request.
+     * Returning a Promise is supported too and the request will stall until it
+     * resolves.
+     *
+     * A good use-case for having a function is when using the URL for authentication,
+     * where subsequent requests (due to auth) may have a refreshed identity token.
+     */
+    headers?: Record<string, string> | (() => Promise<Record<string, string> | null | void> | Record<string, string> | null | void);
+    /**
+     * Control whether the network request error should be retried.
+     *
+     * Please note that you can **only** control network errors, all other
+     * errors are considered fatal and will be reported immediately.
+     *
+     * You may implement your own waiting strategy by timing the resolution of the returned promise.
+     *
+     * Useful for retrying requests that failed because the service is temporarely unavailable.
+     *
+     * `retries` argument counts actual retries, so it will begin with
+     * 0 after the first failed request.
+     *
+     * Returning `false` will report the `err` argument; however, throwing a different error from
+     * the `err` argument, will report it instead.
+     *
+     * @default '() => false'
+     */
+    shouldRetry?: (err: NetworkError, retries: number) => Promise<boolean>;
+    /**
+     * The Fetch function to use.
+     *
+     * For NodeJS environments consider using [`node-fetch`](https://github.com/node-fetch/node-fetch).
+     *
+     * @default global.fetch
+     */
+    fetchFn?: unknown;
+    /**
+     * The AbortController implementation to use.
+     *
+     * For NodeJS environments before v15 consider using [`node-abort-controller`](https://github.com/southpolesteve/node-abort-controller).
+     *
+     * @default global.AbortController
+     */
+    abortControllerImpl?: unknown;
+}
+/** @category Client */
+export interface Client {
+    /**
+     * Subscribes to receive a response by making an HTTP request.
+     *
+     * It uses the `sink` to emit the received data or errors. Returns a _dispose_
+     * function used for canceling active requests and cleaning up.
+     */
+    subscribe<Data = Record<string, unknown>, Extensions = unknown>(request: RequestParams, sink: Sink<ExecutionResult<Data, Extensions>>): () => void;
+    /**
+     * Dispose of the client, cancel all active requests and clean up resources.
+     */
+    dispose: () => void;
+}
+/**
+ * Creates a disposable GraphQL over HTTP client to transmit
+ * GraphQL operation results.
+ *
+ * @category Client
+ */
+export declare function createClient(options: ClientOptions): Client;
+/**
+ * A network error caused by the client or an unexpected response from the server.
+ *
+ * To avoid bundling DOM typings (because the client can run in Node env too),
+ * you should supply the `Response` generic depending on your Fetch implementation.
+ *
+ * @category Client
+ */
+export declare class NetworkError<Response extends ResponseLike = ResponseLike> extends Error {
+    /**
+     * The underlyig response thats considered an error.
+     *
+     * Will be undefined when no response is received,
+     * instead an unexpected network error.
+     */
+    response: Response | undefined;
+    constructor(msgOrErrOrResponse: string | Error | Response);
+}
+/**
+ * Concrete interface a response needs to implement for the client.
+ *
+ * @category Client
+ */
+export interface ResponseLike {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+}

package/lib/common.d.mts

@@ -0,0 +1,31 @@
+/**
+ *
+ * common
+ *
+ */
+/**
+ * Parameters for GraphQL's request for execution.
+ *
+ * Reference: https://graphql.github.io/graphql-over-http/draft/#sec-Request-Parameters
+ *
+ * @category Common
+ */
+export interface RequestParams {
+    operationName?: string | undefined;
+    query: string;
+    variables?: Record<string, unknown> | undefined;
+    extensions?: Record<string, unknown> | undefined;
+}
+/**
+ * A representation of any set of values over any amount of time.
+ *
+ * @category Common
+ */
+export interface Sink<T = unknown> {
+    /** Next value arriving. */
+    next(value: T): void;
+    /** An error that has occured. This function "closes" the sink. */
+    error(error: unknown): void;
+    /** The sink has completed. This function "closes" the sink. */
+    complete(): void;
+}

package/lib/handler.d.mts

@@ -0,0 +1,287 @@
+/**
+ *
+ * handler
+ *
+ */
+import { ExecutionArgs, ExecutionResult, GraphQLSchema, validate as graphqlValidate, execute as graphqlExecute, parse as graphqlParse, getOperationAST as graphqlGetOperationAST, GraphQLError } from 'graphql';
+import { RequestParams } from './common';
+/**
+ * The incoming request headers the implementing server should provide.
+ *
+ * @category Server
+ */
+export declare type RequestHeaders = {
+    /**
+     * Always an array in Node. Duplicates are added to it.
+     * Not necessarily true for other environments.
+     */
+    'set-cookie'?: string | string[] | undefined;
+    [key: string]: string | string[] | undefined;
+} | {
+    get: (key: string) => string | null;
+};
+/**
+ * Server agnostic request interface containing the raw request
+ * which is server dependant.
+ *
+ * @category Server
+ */
+export interface Request<Raw, Context> {
+    readonly method: string;
+    readonly url: string;
+    readonly headers: RequestHeaders;
+    /**
+     * Parsed request body or a parser function.
+     *
+     * If the provided function throws, the error message "Unparsable JSON body" will
+     * be in the erroneous response.
+     */
+    readonly body: string | Record<string, unknown> | null | (() => string | Record<string, unknown> | null | Promise<string | Record<string, unknown> | null>);
+    /**
+     * The raw request itself from the implementing server.
+     *
+     * For example: `express.Request` when using Express, or maybe
+     * `http.IncomingMessage` when just using Node with `http.createServer`.
+     */
+    readonly raw: Raw;
+    /**
+     * Context value about the incoming request, you're free to pass any information here.
+     */
+    readonly context: Context;
+}
+/**
+ * The response headers that get returned from graphql-http.
+ *
+ * @category Server
+ */
+export declare type ResponseHeaders = {
+    accept?: string;
+    allow?: string;
+    'content-type'?: string;
+} & Record<string, string>;
+/**
+ * Server agnostic response body returned from `graphql-http` needing
+ * to be coerced to the server implementation in use.
+ *
+ * @category Server
+ */
+export declare type ResponseBody = string;
+/**
+ * Server agnostic response options (ex. status and headers) returned from
+ * `graphql-http` needing to be coerced to the server implementation in use.
+ *
+ * @category Server
+ */
+export interface ResponseInit {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers?: ResponseHeaders;
+}
+/**
+ * Server agnostic response returned from `graphql-http` containing the
+ * body and init options needing to be coerced to the server implementation in use.
+ *
+ * @category Server
+ */
+export declare type Response = readonly [body: ResponseBody | null, init: ResponseInit];
+/**
+ * Checks whether the passed value is the `graphql-http` server agnostic response.
+ *
+ * @category Server
+ */
+export declare function isResponse(val: unknown): val is Response;
+/**
+ * A concrete GraphQL execution context value type.
+ *
+ * Mainly used because TypeScript collapes unions
+ * with `any` or `unknown` to `any` or `unknown`. So,
+ * we use a custom type to allow definitions such as
+ * the `context` server option.
+ *
+ * @category Server
+ */
+export declare type OperationContext = Record<PropertyKey, unknown> | symbol | number | string | boolean | undefined | null;
+/** @category Server */
+export declare type OperationArgs<Context extends OperationContext = undefined> = ExecutionArgs & {
+    contextValue?: Context;
+};
+/** @category Server */
+export interface HandlerOptions<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined> {
+    /**
+     * The GraphQL schema on which the operations will
+     * be executed and validated against.
+     *
+     * If a function is provided, it will be called on every
+     * operation request allowing you to manipulate schema
+     * dynamically.
+     *
+     * If the schema is left undefined, you're trusted to
+     * provide one in the returned `ExecutionArgs` from the
+     * `onSubscribe` callback.
+     *
+     * If you want to respond to the client with a custom status and/or body,
+     * you should do by returning a `Request` argument which will stop
+     * further execution.
+     */
+    schema?: GraphQLSchema | ((req: Request<RequestRaw, RequestContext>, args: Omit<OperationArgs<Context>, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
+    /**
+     * A value which is provided to every resolver and holds
+     * important contextual information like the currently
+     * logged in user, or access to a database.
+     */
+    context?: Context | ((req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<Context | Response> | Context | Response);
+    /**
+     * A custom GraphQL validate function allowing you to apply your
+     * own validation rules.
+     *
+     * Will not be used when implementing a custom `onSubscribe`.
+     */
+    validate?: typeof graphqlValidate;
+    /**
+     * Is the `execute` function from GraphQL which is
+     * used to execute the query and mutation operations.
+     */
+    execute?: typeof graphqlExecute;
+    /**
+     * GraphQL parse function allowing you to apply a custom parser.
+     */
+    parse?: typeof graphqlParse;
+    /**
+     * GraphQL operation AST getter used for detecting the operation type.
+     */
+    getOperationAST?: typeof graphqlGetOperationAST;
+    /**
+     * The subscribe callback executed right after processing the request
+     * before proceeding with the GraphQL operation execution.
+     *
+     * If you return `ExecutionResult` from the callback, it will be used
+     * directly for responding to the request. Useful for implementing a response
+     * cache.
+     *
+     * If you return `ExecutionArgs` from the callback, it will be used instead of
+     * trying to build one internally. In this case, you are responsible for providing
+     * a ready set of arguments which will be directly plugged in the operation execution.
+     *
+     * You *must* validate the `ExecutionArgs` yourself if returning them.
+     *
+     * If you return an array of `GraphQLError` from the callback, they will be reported
+     * to the client while complying with the spec.
+     *
+     * Omitting the fields `contextValue` from the returned `ExecutionArgs` will use the
+     * provided `context` option, if available.
+     *
+     * Useful for preparing the execution arguments following a custom logic. A typical
+     * use-case is persisted queries. You can identify the query from the request parameters
+     * and supply the appropriate GraphQL operation execution arguments.
+     *
+     * If you want to respond to the client with a custom status and/or body,
+     * you should do by returning a `Request` argument which will stop
+     * further execution.
+     */
+    onSubscribe?: (req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void> | ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void;
+    /**
+     * Executed after the operation call resolves.
+     *
+     * The `OperationResult` argument is the result of operation
+     * execution. It can be an iterator or already a value.
+     *
+     * Use this callback to listen for GraphQL operations and
+     * execution result manipulation.
+     *
+     * If you want to respond to the client with a custom status and/or body,
+     * you should do by returning a `Request` argument which will stop
+     * further execution.
+     */
+    onOperation?: (req: Request<RequestRaw, RequestContext>, args: OperationArgs<Context>, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
+}
+/**
+ * The ready-to-use handler. Simply plug it in your favourite HTTP framework
+ * and enjoy.
+ *
+ * Errors thrown from **any** of the provided options or callbacks (or even due to
+ * library misuse or potential bugs) will reject the handler's promise. They are
+ * considered internal errors and you should take care of them accordingly.
+ *
+ * @category Server
+ */
+export declare type Handler<RequestRaw = unknown, RequestContext = unknown> = (req: Request<RequestRaw, RequestContext>) => Promise<Response>;
+/**
+ * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
+ * be used with your favourite server library.
+ *
+ * Beware that the handler resolves only after the whole operation completes.
+ *
+ * Errors thrown from **any** of the provided options or callbacks (or even due to
+ * library misuse or potential bugs) will reject the handler's promise. They are
+ * considered internal errors and you should take care of them accordingly.
+ *
+ * For production environments, its recommended not to transmit the exact internal
+ * error details to the client, but instead report to an error logging tool or simply
+ * the console.
+ *
+ * Simple example usage with Node:
+ *
+ * ```js
+ * import http from 'http';
+ * import { createHandler } from 'graphql-http';
+ * import { schema } from './my-graphql-schema';
+ *
+ * // Create the GraphQL over HTTP handler
+ * const handler = createHandler({ schema });
+ *
+ * // Create a HTTP server using the handler on `/graphql`
+ * const server = http.createServer(async (req, res) => {
+ *   if (!req.url.startsWith('/graphql')) {
+ *     return res.writeHead(404).end();
+ *   }
+ *
+ *   try {
+ *     const [body, init] = await handler({
+ *       url: req.url,
+ *       method: req.method,
+ *       headers: req.headers,
+ *       body: () => new Promise((resolve) => {
+ *         let body = '';
+ *         req.on('data', (chunk) => (body += chunk));
+ *         req.on('end', () => resolve(body));
+ *       }),
+ *       raw: req,
+ *     });
+ *     res.writeHead(init.status, init.statusText, init.headers).end(body);
+ *   } catch (err) {
+ *     // BEWARE not to transmit the exact internal error message in production environments
+ *     res.writeHead(500).end(err.message);
+ *   }
+ * });
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server
+ */
+export declare function createHandler<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined>(options: HandlerOptions<RequestRaw, RequestContext, Context>): Handler<RequestRaw, RequestContext>;
+/**
+ * Request's Media-Type that the server accepts.
+ *
+ * @category Server
+ */
+export declare type AcceptableMediaType = 'application/graphql-response+json' | 'application/json';
+/**
+ * Inspects the request and detects the appropriate/acceptable Media-Type
+ * looking at the `Accept` header while complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+export declare function getAcceptableMediaType(acceptHeader: string | null | undefined): AcceptableMediaType | null;
+/**
+ * Creates an appropriate GraphQL over HTTP response following the provided arguments.
+ *
+ * If the first argument is an `ExecutionResult`, the operation will be treated as "successful".
+ *
+ * If the first argument is _any_ object without the `data` field, it will be treated as an error (as per the spec)
+ * and the response will be constructed with the help of `acceptedMediaType` complying with the GraphQL over HTTP Protocol.
+ *
+ * @category Server
+ */
+export declare function makeResponse(resultOrErrors: Readonly<ExecutionResult> | Readonly<GraphQLError[]> | Readonly<GraphQLError>, acceptedMediaType: AcceptableMediaType): Response;

package/lib/handler.d.ts

@@ -8,27 +8,25 @@ import { RequestParams } from './common';
 /**
  * The incoming request headers the implementing server should provide.
  *
- * @category Common
+ * @category Server
  */
-export interface RequestHeaders {
-    accept?: string | undefined;
-    allow?: string | undefined;
-    'content-type'?: string | undefined;
+export declare type RequestHeaders = {
     /**
      * Always an array in Node. Duplicates are added to it.
-     * Not necessarily true for other environments, make sure
-     * to check the type during runtime.
+     * Not necessarily true for other environments.
      */
     'set-cookie'?: string | string[] | undefined;
     [key: string]: string | string[] | undefined;
-}
+} | {
+    get: (key: string) => string | null;
+};
 /**
  * Server agnostic request interface containing the raw request
  * which is server dependant.
  *
- * @category Common
+ * @category Server
  */
-export interface Request<RawRequest, Context> {
+export interface Request<Raw, Context> {
     readonly method: string;
     readonly url: string;
     readonly headers: RequestHeaders;
@@ -45,7 +43,7 @@ export interface Request<RawRequest, Context> {
      * For example: `express.Request` when using Express, or maybe
      * `http.IncomingMessage` when just using Node with `http.createServer`.
      */
-    readonly raw: RawRequest;
+    readonly raw: Raw;
     /**
      * Context value about the incoming request, you're free to pass any information here.
      */
@@ -54,7 +52,7 @@ export interface Request<RawRequest, Context> {
 /**
  * The response headers that get returned from graphql-http.
  *
- * @category Common
+ * @category Server
  */
 export declare type ResponseHeaders = {
     accept?: string;
@@ -65,14 +63,14 @@ export declare type ResponseHeaders = {
  * Server agnostic response body returned from `graphql-http` needing
  * to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export declare type ResponseBody = string;
 /**
  * Server agnostic response options (ex. status and headers) returned from
  * `graphql-http` needing to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export interface ResponseInit {
     readonly status: number;
@@ -83,13 +81,13 @@ export interface ResponseInit {
  * Server agnostic response returned from `graphql-http` containing the
  * body and init options needing to be coerced to the server implementation in use.
  *
- * @category Common
+ * @category Server
  */
 export declare type Response = readonly [body: ResponseBody | null, init: ResponseInit];
 /**
  * Checks whether the passed value is the `graphql-http` server agnostic response.
  *
- * @category Common
+ * @category Server
  */
 export declare function isResponse(val: unknown): val is Response;
 /**
@@ -102,9 +100,13 @@ export declare function isResponse(val: unknown): val is Response;
  *
  * @category Server
  */
-export declare type ExecutionContext = object | symbol | number | string | boolean | undefined | null;
+export declare type OperationContext = Record<PropertyKey, unknown> | symbol | number | string | boolean | undefined | null;
+/** @category Server */
+export declare type OperationArgs<Context extends OperationContext = undefined> = ExecutionArgs & {
+    contextValue?: Context;
+};
 /** @category Server */
-export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
+export interface HandlerOptions<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined> {
     /**
      * The GraphQL schema on which the operations will
      * be executed and validated against.
@@ -121,13 +123,13 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    schema?: GraphQLSchema | ((req: Request<RawRequest, Context>, args: Omit<ExecutionArgs, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
+    schema?: GraphQLSchema | ((req: Request<RequestRaw, RequestContext>, args: Omit<OperationArgs<Context>, 'schema'>) => Promise<GraphQLSchema | Response> | GraphQLSchema | Response);
     /**
      * A value which is provided to every resolver and holds
      * important contextual information like the currently
      * logged in user, or access to a database.
      */
-    context?: ExecutionContext | ((req: Request<RawRequest, Context>, args: ExecutionArgs) => Promise<ExecutionContext | Response> | ExecutionContext | Response);
+    context?: Context | ((req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<Context | Response> | Context | Response);
     /**
      * A custom GraphQL validate function allowing you to apply your
      * own validation rules.
@@ -176,7 +178,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onSubscribe?: (req: Request<RawRequest, Context>, params: RequestParams) => Promise<ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void> | ExecutionResult | ExecutionArgs | readonly GraphQLError[] | Response | void;
+    onSubscribe?: (req: Request<RequestRaw, RequestContext>, params: RequestParams) => Promise<ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void> | ExecutionResult | OperationArgs<Context> | readonly GraphQLError[] | Response | void;
     /**
      * Executed after the operation call resolves.
      *
@@ -190,7 +192,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
      * you should do by returning a `Request` argument which will stop
      * further execution.
      */
-    onOperation?: (req: Request<RawRequest, Context>, args: ExecutionArgs, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
+    onOperation?: (req: Request<RequestRaw, RequestContext>, args: OperationArgs<Context>, result: ExecutionResult) => Promise<ExecutionResult | Response | void> | ExecutionResult | Response | void;
 }
 /**
  * The ready-to-use handler. Simply plug it in your favourite HTTP framework
@@ -202,7 +204,7 @@ export interface HandlerOptions<RawRequest = unknown, Context = unknown> {
  *
  * @category Server
  */
-export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Request<RawRequest, Context>) => Promise<Response>;
+export declare type Handler<RequestRaw = unknown, RequestContext = unknown> = (req: Request<RequestRaw, RequestContext>) => Promise<Response>;
 /**
  * Makes a GraphQL over HTTP Protocol compliant server handler. The handler can
  * be used with your favourite server library.
@@ -258,7 +260,7 @@ export declare type Handler<RawRequest = unknown, Context = unknown> = (req: Req
  *
  * @category Server
  */
-export declare function createHandler<RawRequest = unknown, Context = unknown>(options: HandlerOptions<RawRequest, Context>): Handler<RawRequest, Context>;
+export declare function createHandler<RequestRaw = unknown, RequestContext = unknown, Context extends OperationContext = undefined>(options: HandlerOptions<RequestRaw, RequestContext, Context>): Handler<RequestRaw, RequestContext>;
 /**
  * Request's Media-Type that the server accepts.
  *