graphql-http 1.20.0 → 1.22.0

package/lib/use/express.mjs

@@ -1,4 +1,53 @@
-import { createHandler as createRawHandler, } from '../handler.mjs';
+import { createHandler as createRawHandler, parseRequestParams as rawParseRequestParams, } from '../handler.mjs';
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `Response` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import express from 'express'; // yarn add express
+ * import { parseRequestParams } from 'graphql-http/lib/use/express';
+ *
+ * const app = express();
+ * app.all('/graphql', async (req, res) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, res);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     res.writeHead(200).end(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     res.writeHead(400).end(err.message);
+ *   }
+ * });
+ *
+ * app.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/express
+ */
+export async function parseRequestParams(req, res) {
+    const rawReq = toRequest(req, res);
+    const paramsOrRes = await rawParseRequestParams(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        res.writeHead(init.status, init.statusText, init.headers).end(body);
+        return null;
+    }
+    return paramsOrRes;
+}
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the express framework.
@@ -21,24 +70,7 @@ export function createHandler(options) {
     const handle = createRawHandler(options);
     return async function requestListener(req, res) {
         try {
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                body: () => {
-                    if (req.body) {
-                        // in case express has a body parser
-                        return req.body;
-                    }
-                    return new Promise((resolve) => {
-                        let body = '';
-                        req.on('data', (chunk) => (body += chunk));
-                        req.on('end', () => resolve(body));
-                    });
-                },
-                raw: req,
-                context: { res },
-            });
+            const [body, init] = await handle(toRequest(req, res));
             res.writeHead(init.status, init.statusText, init.headers).end(body);
         }
         catch (err) {
@@ -50,3 +82,23 @@ export function createHandler(options) {
         }
     };
 }
+function toRequest(req, res) {
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        body: () => {
+            if (req.body) {
+                // in case express has a body parser
+                return req.body;
+            }
+            return new Promise((resolve) => {
+                let body = '';
+                req.on('data', (chunk) => (body += chunk));
+                req.on('end', () => resolve(body));
+            });
+        },
+        raw: req,
+        context: { res },
+    };
+}

package/lib/use/fastify.d.mts

@@ -1,5 +1,6 @@
 import type { FastifyRequest, FastifyReply, RouteHandler } from 'fastify';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler.mjs';
+import { RequestParams } from '../common.mjs';
 /**
  * The context in the request for the handler.
  *
@@ -8,6 +9,46 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     reply: FastifyReply;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `FastifyReply` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { parseRequestParams } from 'graphql-http/lib/use/fastify';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', async (req, reply) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, reply);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     reply.status(200).send(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     reply.status(400).send(err.message);
+ *   }
+ * });
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export declare function parseRequestParams(req: FastifyRequest, reply: FastifyReply): Promise<RequestParams | null>;
 /**
  * Handler options when using the fastify adapter.
  *
@@ -20,7 +61,7 @@ export type HandlerOptions<Context extends OperationContext = undefined> = RawHa
  *
  * ```js
  * import Fastify from 'fastify'; // yarn add fastify
- * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { createHandler } from 'graphql-http/lib/use/fastify';
  * import { schema } from './my-graphql-schema/index.mjs';
  *
  * const fastify = Fastify();

package/lib/use/fastify.d.ts

@@ -1,5 +1,6 @@
 import type { FastifyRequest, FastifyReply, RouteHandler } from 'fastify';
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The context in the request for the handler.
  *
@@ -8,6 +9,46 @@ import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handle
 export interface RequestContext {
     reply: FastifyReply;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `FastifyReply` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { parseRequestParams } from 'graphql-http/lib/use/fastify';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', async (req, reply) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, reply);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     reply.status(200).send(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     reply.status(400).send(err.message);
+ *   }
+ * });
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export declare function parseRequestParams(req: FastifyRequest, reply: FastifyReply): Promise<RequestParams | null>;
 /**
  * Handler options when using the fastify adapter.
  *
@@ -20,7 +61,7 @@ export type HandlerOptions<Context extends OperationContext = undefined> = RawHa
  *
  * ```js
  * import Fastify from 'fastify'; // yarn add fastify
- * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { createHandler } from 'graphql-http/lib/use/fastify';
  * import { schema } from './my-graphql-schema';
  *
  * const fastify = Fastify();

package/lib/use/fastify.js

@@ -1,14 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHandler = void 0;
+exports.createHandler = exports.parseRequestParams = void 0;
 const handler_1 = require("../handler");
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `FastifyReply` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { parseRequestParams } from 'graphql-http/lib/use/fastify';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', async (req, reply) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, reply);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     reply.status(200).send(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     reply.status(400).send(err.message);
+ *   }
+ * });
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+async function parseRequestParams(req, reply) {
+    const rawReq = toRequest(req, reply);
+    const paramsOrRes = await (0, handler_1.parseRequestParams)(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        reply
+            .status(init.status)
+            .headers(init.headers || {})
+            // "or undefined" because `null` will be JSON stringified
+            .send(body || undefined);
+        return null;
+    }
+    return paramsOrRes;
+}
+exports.parseRequestParams = parseRequestParams;
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the fastify framework.
  *
  * ```js
  * import Fastify from 'fastify'; // yarn add fastify
- * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { createHandler } from 'graphql-http/lib/use/fastify';
  * import { schema } from './my-graphql-schema';
  *
  * const fastify = Fastify();
@@ -24,15 +78,7 @@ function createHandler(options) {
     const handle = (0, handler_1.createHandler)(options);
     return async function requestListener(req, reply) {
         try {
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                body: req.body,
-                raw: req,
-                context: { reply },
-            });
+            const [body, init] = await handle(toRequest(req, reply));
             reply
                 .status(init.status)
                 .headers(init.headers || {})
@@ -49,3 +95,14 @@ function createHandler(options) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(req, reply) {
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        body: req.body,
+        raw: req,
+        context: { reply },
+    };
+}

package/lib/use/fastify.mjs

@@ -1,11 +1,64 @@
-import { createHandler as createRawHandler, } from '../handler.mjs';
+import { createHandler as createRawHandler, parseRequestParams as rawParseRequestParams, } from '../handler.mjs';
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will respond
+ * on the `FastifyReply` argument and return `null`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import Fastify from 'fastify'; // yarn add fastify
+ * import { parseRequestParams } from 'graphql-http/lib/use/fastify';
+ *
+ * const fastify = Fastify();
+ * fastify.all('/graphql', async (req, reply) => {
+ *   try {
+ *     const maybeParams = await parseRequestParams(req, reply);
+ *     if (!maybeParams) {
+ *       // not a well-formatted GraphQL over HTTP request,
+ *       // parser responded and there's nothing else to do
+ *       return;
+ *     }
+ *
+ *     // well-formatted GraphQL over HTTP request,
+ *     // with valid parameters
+ *     reply.status(200).send(JSON.stringify(maybeParams, null, '  '));
+ *   } catch (err) {
+ *     // well-formatted GraphQL over HTTP request,
+ *     // but with invalid parameters
+ *     reply.status(400).send(err.message);
+ *   }
+ * });
+ *
+ * fastify.listen({ port: 4000 });
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fastify
+ */
+export async function parseRequestParams(req, reply) {
+    const rawReq = toRequest(req, reply);
+    const paramsOrRes = await rawParseRequestParams(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        reply
+            .status(init.status)
+            .headers(init.headers || {})
+            // "or undefined" because `null` will be JSON stringified
+            .send(body || undefined);
+        return null;
+    }
+    return paramsOrRes;
+}
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * the fastify framework.
  *
  * ```js
  * import Fastify from 'fastify'; // yarn add fastify
- * import { createHandler } from 'graphql-http/lib/use/express';
+ * import { createHandler } from 'graphql-http/lib/use/fastify';
  * import { schema } from './my-graphql-schema/index.mjs';
  *
  * const fastify = Fastify();
@@ -21,15 +74,7 @@ export function createHandler(options) {
     const handle = createRawHandler(options);
     return async function requestListener(req, reply) {
         try {
-            const [body, init] = await handle({
-                url: req.url,
-                method: req.method,
-                headers: req.headers,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                body: req.body,
-                raw: req,
-                context: { reply },
-            });
+            const [body, init] = await handle(toRequest(req, reply));
             reply
                 .status(init.status)
                 .headers(init.headers || {})
@@ -45,3 +90,14 @@ export function createHandler(options) {
         }
     };
 }
+function toRequest(req, reply) {
+    return {
+        url: req.url,
+        method: req.method,
+        headers: req.headers,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        body: req.body,
+        raw: req,
+        context: { reply },
+    };
+}

package/lib/use/fetch.d.mts

@@ -1,4 +1,5 @@
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler.mjs';
+import { RequestParams } from '../common.mjs';
 /**
  * The necessary API from the fetch environment for the handler.
  *
@@ -9,6 +10,55 @@ export interface FetchAPI {
     ReadableStream: typeof ReadableStream;
     TextEncoder: typeof TextEncoder;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * It is important to pass in the `abortedRef` so that the parser does not perform any
+ * operations on a disposed request (see example).
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will return a `Response`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import http from 'http';
+ * import { createServerAdapter } from '@whatwg-node/server'; // yarn add @whatwg-node/server
+ * import { parseRequestParams } from 'graphql-http/lib/use/fetch';
+ *
+ * // Use this adapter in _any_ environment.
+ * const adapter = createServerAdapter({
+ *   handleRequest: async (req) => {
+ *     try {
+ *       const paramsOrResponse = await parseRequestParams(req);
+ *       if (paramsOrResponse instanceof Response) {
+ *         // not a well-formatted GraphQL over HTTP request,
+ *         // parser created a response object to use
+ *         return paramsOrResponse;
+ *       }
+ *
+ *       // well-formatted GraphQL over HTTP request,
+ *       // with valid parameters
+ *       return new Response(JSON.stringify(paramsOrResponse, null, '  '), {
+ *         status: 200,
+ *       });
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       return new Response(err.message, { status: 400 });
+ *     }
+ *   },
+ * });
+ *
+ * const server = http.createServer(adapter);
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fetch
+ */
+export declare function parseRequestParams(req: Request, api?: Partial<FetchAPI>): Promise<RequestParams | Response>;
 /**
  * Handler options when using the fetch adapter.
  *

package/lib/use/fetch.d.ts

@@ -1,4 +1,5 @@
 import { HandlerOptions as RawHandlerOptions, OperationContext } from '../handler';
+import { RequestParams } from '../common';
 /**
  * The necessary API from the fetch environment for the handler.
  *
@@ -9,6 +10,55 @@ export interface FetchAPI {
     ReadableStream: typeof ReadableStream;
     TextEncoder: typeof TextEncoder;
 }
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * It is important to pass in the `abortedRef` so that the parser does not perform any
+ * operations on a disposed request (see example).
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will return a `Response`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import http from 'http';
+ * import { createServerAdapter } from '@whatwg-node/server'; // yarn add @whatwg-node/server
+ * import { parseRequestParams } from 'graphql-http/lib/use/fetch';
+ *
+ * // Use this adapter in _any_ environment.
+ * const adapter = createServerAdapter({
+ *   handleRequest: async (req) => {
+ *     try {
+ *       const paramsOrResponse = await parseRequestParams(req);
+ *       if (paramsOrResponse instanceof Response) {
+ *         // not a well-formatted GraphQL over HTTP request,
+ *         // parser created a response object to use
+ *         return paramsOrResponse;
+ *       }
+ *
+ *       // well-formatted GraphQL over HTTP request,
+ *       // with valid parameters
+ *       return new Response(JSON.stringify(paramsOrResponse, null, '  '), {
+ *         status: 200,
+ *       });
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       return new Response(err.message, { status: 400 });
+ *     }
+ *   },
+ * });
+ *
+ * const server = http.createServer(adapter);
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fetch
+ */
+export declare function parseRequestParams(req: Request, api?: Partial<FetchAPI>): Promise<RequestParams | Response>;
 /**
  * Handler options when using the fetch adapter.
  *

package/lib/use/fetch.js

@@ -1,7 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHandler = void 0;
+exports.createHandler = exports.parseRequestParams = void 0;
 const handler_1 = require("../handler");
+/**
+ * The GraphQL over HTTP spec compliant request parser for an incoming GraphQL request.
+ *
+ * It is important to pass in the `abortedRef` so that the parser does not perform any
+ * operations on a disposed request (see example).
+ *
+ * If the HTTP request _is not_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), the function will return a `Response`.
+ *
+ * If the HTTP request _is_ a [well-formatted GraphQL over HTTP request](https://graphql.github.io/graphql-over-http/draft/#sec-Request), but is invalid or malformed,
+ * the function will throw an error and it is up to the user to handle and respond as they see fit.
+ *
+ * ```js
+ * import http from 'http';
+ * import { createServerAdapter } from '@whatwg-node/server'; // yarn add @whatwg-node/server
+ * import { parseRequestParams } from 'graphql-http/lib/use/fetch';
+ *
+ * // Use this adapter in _any_ environment.
+ * const adapter = createServerAdapter({
+ *   handleRequest: async (req) => {
+ *     try {
+ *       const paramsOrResponse = await parseRequestParams(req);
+ *       if (paramsOrResponse instanceof Response) {
+ *         // not a well-formatted GraphQL over HTTP request,
+ *         // parser created a response object to use
+ *         return paramsOrResponse;
+ *       }
+ *
+ *       // well-formatted GraphQL over HTTP request,
+ *       // with valid parameters
+ *       return new Response(JSON.stringify(paramsOrResponse, null, '  '), {
+ *         status: 200,
+ *       });
+ *     } catch (err) {
+ *       // well-formatted GraphQL over HTTP request,
+ *       // but with invalid parameters
+ *       return new Response(err.message, { status: 400 });
+ *     }
+ *   },
+ * });
+ *
+ * const server = http.createServer(adapter);
+ *
+ * server.listen(4000);
+ * console.log('Listening to port 4000');
+ * ```
+ *
+ * @category Server/fetch
+ */
+async function parseRequestParams(req, api = {}) {
+    const rawReq = toRequest(req, api);
+    const paramsOrRes = await (0, handler_1.parseRequestParams)(rawReq);
+    if (!('query' in paramsOrRes)) {
+        const [body, init] = paramsOrRes;
+        return new (api.Response || Response)(body, init);
+    }
+    return paramsOrRes;
+}
+exports.parseRequestParams = parseRequestParams;
 /**
  * Create a GraphQL over HTTP spec compliant request handler for
  * a fetch environment like Deno, Bun, CloudFlare Workers, Lambdas, etc.
@@ -39,14 +97,7 @@ function createHandler(options, reqCtx = {}) {
     const handler = (0, handler_1.createHandler)(options);
     return async function handleRequest(req) {
         try {
-            const [body, init] = await handler({
-                method: req.method,
-                url: req.url,
-                headers: req.headers,
-                body: () => req.text(),
-                raw: req,
-                context: api,
-            });
+            const [body, init] = await handler(toRequest(req, api));
             return new api.Response(body, init);
         }
         catch (err) {
@@ -59,3 +110,17 @@ function createHandler(options, reqCtx = {}) {
     };
 }
 exports.createHandler = createHandler;
+function toRequest(req, api = {}) {
+    return {
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+        body: () => req.text(),
+        raw: req,
+        context: {
+            Response: api.Response || Response,
+            TextEncoder: api.TextEncoder || TextEncoder,
+            ReadableStream: api.ReadableStream || ReadableStream,
+        },
+    };
+}