diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index a6205409..f8183d5a 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -22,6 +22,7 @@
 │   ├── FSharp.Data.GraphQL.Server.AspNetCore/  – ASP.NET Core integration (HTTP and WebSocket)
 │   ├── FSharp.Data.GraphQL.Server.Giraffe/     – Giraffe integration
 │   ├── FSharp.Data.GraphQL.Server.Oxpecker/    – Oxpecker integration
+│   ├── FSharp.Data.GraphQL.Server.Suave/       – Suave integration
 │   ├── FSharp.Data.GraphQL.Client/             – client type provider runtime
 │   └── FSharp.Data.GraphQL.Client.DesignTime/  – client type provider design-time component
 ├── tests/
diff --git a/FSharp.Data.GraphQL.slnx b/FSharp.Data.GraphQL.slnx
index 271e8c90..bf5edfe3 100644
--- a/FSharp.Data.GraphQL.slnx
+++ b/FSharp.Data.GraphQL.slnx
@@ -34,6 +34,7 @@
   </Folder>
   <Folder Name="/samples/">
     <Project Path="samples/chat-app/server/chat-app.fsproj" />
+    <Project Path="samples/magic-eight-ball/magic-eight-ball.fsproj" />
     <Project Path="samples/relay-book-store/relay-book-store.fsproj" />
     <Project Path="samples/star-wars-api/star-wars-api.fsproj" />
   </Folder>
@@ -123,6 +124,7 @@
     <Project Path="src/FSharp.Data.GraphQL.Server.Middleware/FSharp.Data.GraphQL.Server.Middleware.fsproj" />
     <Project Path="src/FSharp.Data.GraphQL.Server.Oxpecker/FSharp.Data.GraphQL.Server.Oxpecker.fsproj" />
     <Project Path="src/FSharp.Data.GraphQL.Server.Relay/FSharp.Data.GraphQL.Server.Relay.fsproj" />
+    <Project Path="src/FSharp.Data.GraphQL.Server.Suave/FSharp.Data.GraphQL.Server.Suave.fsproj" />
     <Project Path="src/FSharp.Data.GraphQL.Server/FSharp.Data.GraphQL.Server.fsproj" />
     <Project Path="src/FSharp.Data.GraphQL.Shared/FSharp.Data.GraphQL.Shared.fsproj" />
   </Folder>
diff --git a/Packages.props b/Packages.props
index 1f810695..84d5e3dd 100644
--- a/Packages.props
+++ b/Packages.props
@@ -28,6 +28,7 @@
     <PackageReference Update="Microsoft.NETCore.Platforms" Version="$(SystemVersion)" />
     <PackageReference Update="NuGet.CommandLine" Version="1.*" />
     <PackageReference Update="Oxpecker" Version="2.*" />
+    <PackageReference Update="Suave" Version="2.6.*" />
     <PackageReference Update="System.CodeDom" Version="$(SystemVersion)" />
     <PackageReference Update="System.Collections.Immutable" Version="$(SystemVersion)" />
     <PackageReference Update="System.Diagnostics.DiagnosticSource" Version="$(SystemVersion)" />
diff --git a/README.md b/README.md
index 1c5b35bf..826a8178 100644
--- a/README.md
+++ b/README.md
@@ -279,17 +279,19 @@ type OperationExecutionMiddleware =
     ExecutionContext -> (ExecutionContext -> AsyncVal<GQLResponse>) -> AsyncVal<GQLResponse>
 
 type IExecutorMiddleware =
-    abstract CompileSchema : SchemaCompileMiddleware option
-    abstract PlanOperation : OperationPlanningMiddleware option
-    abstract ExecuteOperationAsync : OperationExecutionMiddleware option
+    abstract CompileSchema : SchemaCompileMiddleware voption
+    abstract PostCompileSchema : SchemaPostCompileMiddleware voption
+    abstract PlanOperation : OperationPlanningMiddleware voption
+    abstract ExecuteOperationAsync : OperationExecutionMiddleware voption
 ```
 
 Optionally, for ease of implementation, concrete class to derive from can be used, receiving only the optional sub-middleware functions in the constructor:
 
 ```fsharp
-type ExecutorMiddleware(?compile, ?plan, ?execute) =
+type ExecutorMiddleware([<Struct>] ?compile, [<Struct>] ?postCompile, [<Struct>] ?plan, [<Struct>] ?execute) =
     interface IExecutorMiddleware with
         member _.CompileSchema = compile
+        member _.PostCompileSchema = postCompile
         member _.PlanOperation = plan
         member _.ExecuteOperationAsync = execute
 ```
@@ -297,7 +299,7 @@ type ExecutorMiddleware(?compile, ?plan, ?execute) =
 Each of the middleware functions act like an intercept function, with two parameters: the context of the phase, the function of the next middleware (or the actual phase itself, which is the last to run), and the return value. Those functions can be passed as an argument to the constructor of the `Executor<'Root>` object:
 
 ```fsharp
-let middleware = [ ExecutorMiddleware(compileFn, planningFn, executionFn) ]
+let middleware = [ ExecutorMiddleware(compile = compileFn, plan = planningFn, execute = executionFn) ]
 let executor = Executor(schema, middleware)
 ```
 
diff --git a/samples/magic-eight-ball/GraphiQL.fs b/samples/magic-eight-ball/GraphiQL.fs
new file mode 100644
index 00000000..ee0f3ffc
--- /dev/null
+++ b/samples/magic-eight-ball/GraphiQL.fs
@@ -0,0 +1,303 @@
+module FSharp.Data.GraphQL.Samples.MagicEightBall.GraphiQL
+
+open Suave
+open Suave.Http
+open Suave.Operators
+
+// `GraphQL.Server.Ui.GraphiQL` (used by the other samples) only ships an ASP.NET Core middleware, so it can't be
+// composed into a Suave `WebPart`. Its `GraphiQLPageModel.Render()` method produces static HTML for a fixed set of
+// options (GraphQL endpoint `/`, subscriptions endpoint `/ws`, `graphql-ws` subscriptions), so that output is
+// hardcoded here instead of invoking the internal renderer through reflection.
+let private page =
+    """<!--
+ *  Copyright (c) 2024 GraphQL Contributors
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the license found in the
+ *  LICENSE file in the root directory of this source tree.
+-->
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <style>
+    body {
+      height: 100%;
+      margin: 0;
+      width: 100%;
+      overflow: hidden;
+    }
+
+    #graphiql {
+      height: 100vh;
+    }
+  </style>
+
+  <!--
+    This GraphiQL example depends on Promise and fetch, which are available in
+    modern browsers, but can be "polyfilled" for older browsers.
+    GraphiQL itself depends on React DOM.
+    If you do not want to rely on a CDN, you can host these files locally or
+    include them directly in your favored resource bunder.
+  -->
+  <script
+    src="https://cdn.jsdelivr.net/npm/whatwg-fetch@2.0.3/fetch.min.js"
+    integrity="sha384-dcF7KoWRaRpjcNbVPUFgatYgAijf8DqW6NWuqLdfB5Sb4Cdbb8iHX7bHsl9YhpKa"
+    crossorigin="anonymous"
+  ></script>
+  <script
+    src="https://unpkg.com/react@16.14.0/umd/react.production.min.js"
+    integrity="sha384-N7y5SSAooNlIfb9H750GR82ufkn1JXJFaCjg8pmt+OZuKcZoTvTGfog4d4taG/cF"
+    crossorigin="anonymous"
+  ></script>
+  <script
+    src="https://unpkg.com/react-dom@16.14.0/umd/react-dom.production.min.js"
+    integrity="sha384-j7WmMv3OO6n8pZRATOsaMVEdZcHpoaTBIika/l92YM2AkEex72QunlTQlgmu+pI8"
+    crossorigin="anonymous"
+  ></script>
+
+  <!--
+    These two files can be found in the npm module, however you may wish to
+    copy them directly into your environment, or perhaps include them in your
+    favored resource bundler.
+   -->
+  <link
+    rel="stylesheet"
+    href="https://unpkg.com/graphiql@3.2.0/graphiql.min.css"
+    integrity="sha384-yz3/sqpuplkA7msMo0FE4ekg0xdwdvZ8JX9MVZREsxipqjU4h8IRfmAMRcb1QpUy"
+    crossorigin="anonymous"
+  />
+  <script
+    src="https://unpkg.com/subscriptions-transport-ws@0.8.2/browser/client.js"
+    integrity="sha384-Eqe2SG8kA+Au+rwrgfWJ+epqYAtKGW/As+WdcywebVKX7377xelWa+/il4CHiHXI"
+    crossorigin="anonymous"
+  ></script>
+  <script
+    src="https://unpkg.com/graphiql-subscriptions-fetcher@0.0.2/browser/client.js"
+    integrity="sha384-ArTEHLNWIe9TuoDpFEtD/NeztNdWn3SdmWwMiAuZaSJeOaYypEGzeQoBxuPO+ORM"
+    crossorigin="anonymous"
+  ></script>
+  <script
+    src="https://unpkg.com/graphql-ws@5.16.0/umd/graphql-ws.min.js"
+    integrity="sha384-oEPbisbEBMo7iCrbQcKx244HXUjGnF1jyS8hkVZ3oCwnw9c9oLfY70c1RKeKj3+i"
+    crossorigin="anonymous"
+  ></script>
+
+</head>
+<body>
+  <div id="graphiql">Loading...</div>
+  <script
+    src="https://unpkg.com/graphiql@3.2.0/graphiql.min.js"
+    type="application/javascript"
+    integrity="sha384-h7T8iQ4OYtRS2RIWfZ7ahqfNRtVrjc6Uz/gUJjydAV/uWn/HgC5GMnSKmsvNGeUH"
+    crossorigin="anonymous"
+  ></script>
+  <script>
+
+    /**
+     * This GraphiQL example illustrates how to use some of GraphiQL's props
+     * in order to enable reading and updating the URL parameters, making
+     * link sharing of queries a little bit easier.
+     *
+     * This is only one example of this kind of feature, GraphiQL exposes
+     * various React params to enable interesting integrations.
+     */
+
+    // Parse the search string to get url parameters.
+    var search = window.location.search;
+    var parameters = {};
+    search.substr(1).split('&').forEach(function (entry) {
+      var eq = entry.indexOf('=');
+      if (eq >= 0) {
+        parameters[decodeURIComponent(entry.slice(0, eq))] =
+          decodeURIComponent(entry.slice(eq + 1));
+      }
+    });
+
+    // if variables was provided, try to format it.
+    if (parameters.variables) {
+      try {
+        parameters.variables =
+          JSON.stringify(JSON.parse(parameters.variables), null, 2);
+      } catch (e) {
+        // Do nothing, we want to display the invalid JSON as a string, rather
+        // than present an error.
+      }
+    }
+
+    // When the query and variables string is edited, update the URL bar so
+    // that it can be easily shared
+    function onEditQuery(newQuery) {
+      parameters.query = newQuery;
+      updateURL();
+    }
+
+    function onEditVariables(newVariables) {
+      parameters.variables = newVariables;
+      updateURL();
+    }
+
+    function onEditOperationName(newOperationName) {
+      parameters.operationName = newOperationName;
+      updateURL();
+    }
+
+    function updateURL() {
+      var newSearch = '?' + Object.keys(parameters).filter(function (key) {
+        return Boolean(parameters[key]);
+      }).map(function (key) {
+        return encodeURIComponent(key) + '=' +
+          encodeURIComponent(parameters[key]);
+      }).join('&');
+      history.replaceState(null, null, newSearch);
+    }
+
+    // Defines a GraphQL fetcher using the fetch API. You're not required to
+    // use fetch, and could instead implement graphQLFetcher however you like,
+    // as long as it returns a Promise or Observable.
+    function graphQLFetcher(graphQLParams, fetcherOpts = { headers: {} }) {
+      // This example expects a GraphQL server at the path /graphql.
+      // Change this to point wherever you host your GraphQL server.
+      return fetch('/', {
+        method: 'post',
+        headers: Object.assign({"Accept":"application/json","Content-Type":"application/json"}, fetcherOpts.headers),
+        body: JSON.stringify(graphQLParams),
+        credentials: 'same-origin',
+      }).then(function (response) {
+        return response.text();
+      }).then(function (responseBody) {
+        try {
+          return JSON.parse(responseBody);
+        } catch (error) {
+          return responseBody;
+        }
+      });
+    }
+
+    function getSubscriptionsEndPoint() {
+      let subscriptionsEndPoint = "/ws";
+      if (/^(?:[a-z]+:)?\/\//i.test(subscriptionsEndPoint)) {
+        // if location includes protocol (e.g. "wss://") then return exact string
+        return subscriptionsEndPoint;
+      } else if (subscriptionsEndPoint[0] != '/') {
+        // if location is relative (e.g. "api") then prepend host and current path
+        let currentUrl = /^[^?]*(?=\/)/.exec(window.location.pathname);
+        currentUrl = currentUrl ? currentUrl[0] : '';
+        while (subscriptionsEndPoint.substring(0, 3) == '../') {
+          subscriptionsEndPoint = subscriptionsEndPoint.substring(3);
+          currentUrl = /^[^?]*(?=\/)/.exec(currentUrl);
+          currentUrl = currentUrl ? currentUrl[0] : '';
+        }
+        return (window.location.protocol === "http:" ? "ws://" : "wss://") + window.location.host + currentUrl + '/' + subscriptionsEndPoint;
+      }
+      // if location is absolute (e.g. "/api") then prepend host only
+      return (window.location.protocol === "http:" ? "ws://" : "wss://") + window.location.host + subscriptionsEndPoint;
+    }
+    const subscriptionEndPoint = getSubscriptionsEndPoint();
+
+    // Enable Subscriptions via WebSocket
+    let subscriptionsClient = null;
+    function subscriptionsTransportWsFetcher(graphQLParams, fetcherOpts = { headers: {} }) {
+      if (!subscriptionsClient)
+        subscriptionsClient = new window.SubscriptionsTransportWs.SubscriptionClient(subscriptionEndPoint, { reconnect: true });
+      return window.GraphiQLSubscriptionsFetcher.graphQLFetcher(subscriptionsClient, function (_graphQLParams) {
+        return graphQLFetcher(_graphQLParams, fetcherOpts);
+      })(graphQLParams);
+    }
+    
+    function isSubscription(operationName, documentAST) {
+      if (!documentAST.definitions || !documentAST.definitions.length || !documentAST.definitions.filter) return false;
+      let definitions = documentAST.definitions.filter(function (def) { return def.kind === 'OperationDefinition'; });
+      if (operationName) definitions = definitions.filter(function (def) { return def.name && def.name.value === operationName; });
+      if (definitions.length === 0) return false;
+      return definitions[0].operation === 'subscription';
+    }
+
+    let wsClient = null;
+    function graphQLWsFetcher(payload, fetcherOpts) {
+      if (!fetcherOpts || !fetcherOpts.documentAST || !isSubscription(payload.operationName, fetcherOpts.documentAST))
+        return graphQLFetcher(payload, fetcherOpts);
+      if (!wsClient) {
+        wsClient = graphqlWs.createClient({ url: subscriptionEndPoint });
+      }
+      let deferred = null;
+      const pending = [];
+      let throwMe = null,
+        done = false;
+      const dispose = wsClient.subscribe(payload, {
+        next: (data) => {
+          pending.push(data);
+          if (deferred) deferred.resolve(false);
+        },
+        error: (err) => {
+          if (err instanceof Error) {
+            throwMe = err;
+          } else if (err instanceof CloseEvent) {
+            throwMe = new Error(`Socket closed with event ${err.code} ${err.reason || ""}`.trim());
+          } else {
+            // GraphQLError[]
+            throwMe = new Error(err.map(({ message }) => message).join(", "));
+          }
+          if (deferred) deferred.reject(throwMe);
+        },
+        complete: () => {
+          done = true;
+          if (deferred) deferred.resolve(true);
+        },
+      });
+
+      return {
+        [Symbol.asyncIterator]: function() {
+          return this;
+        },
+        next: function() {
+          if (done) return Promise.resolve({ done: true, value: undefined });
+          if (throwMe) return Promise.reject(throwMe);
+          if (pending.length) return Promise.resolve({ value: pending.shift() });
+          return new Promise(function(resolve, reject) {
+            deferred = { resolve, reject };
+          }).then(function(result) {
+            if (result) {
+              return { done: true, value: undefined };
+            } else {
+              return { value: pending.shift() };
+            }
+          });
+        },
+        return: function() {
+          dispose();
+          return Promise.resolve({ done: true, value: undefined });
+        }
+      };
+    }
+
+    const subscriptionFetcher = (true) ? graphQLWsFetcher : subscriptionsTransportWsFetcher;
+
+    // Render <GraphiQL /> into the body.
+    // See the README in the top level of this module to learn more about
+    // how you can customize GraphiQL by providing different values or
+    // additional child elements.
+    ReactDOM.render(
+      React.createElement(GraphiQL, {
+        fetcher: subscriptionFetcher,
+        query: parameters.query,
+        variables: parameters.variables,
+        operationName: parameters.operationName,
+        onEditQuery: onEditQuery,
+        onEditVariables: onEditVariables,
+        onEditOperationName: onEditOperationName,
+        isHeadersEditorEnabled: true,
+      }),
+      document.getElementById('graphiql'),
+    );
+  </script>
+</body>
+</html>
+"""
+
+/// <summary>A <see cref="Suave.Http.WebPart"/> that serves the GraphiQL IDE at <c>/graphiql</c>, pointed at the GraphQL API served at <c>/</c>.</summary>
+let webPart : WebPart =
+    Filters.path "/graphiql"
+    >=> Filters.GET
+    >=> Writers.setMimeType "text/html; charset=utf-8"
+    >=> Successful.OK page
diff --git a/samples/magic-eight-ball/Program.fs b/samples/magic-eight-ball/Program.fs
new file mode 100644
index 00000000..d6c3e547
--- /dev/null
+++ b/samples/magic-eight-ball/Program.fs
@@ -0,0 +1,22 @@
+module FSharp.Data.GraphQL.Samples.MagicEightBall.Program
+
+open System
+open Suave
+open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Server.Suave
+open FSharp.Data.GraphQL.Samples.MagicEightBall.GraphiQL
+open FSharp.Data.GraphQL.Samples.MagicEightBall.Schema
+
+[<EntryPoint>]
+let main _ =
+    let random = Random ()
+
+    let rootFactory (_ctx : HttpContext) : Root = { Random = random }
+
+    let executor = Executor (schema)
+
+    let app = choose [ webPart; GraphQL.graphQL executor rootFactory ]
+
+    startWebServer defaultConfig app
+
+    0
diff --git a/samples/magic-eight-ball/README.md b/samples/magic-eight-ball/README.md
new file mode 100644
index 00000000..971ddbc7
--- /dev/null
+++ b/samples/magic-eight-ball/README.md
@@ -0,0 +1,36 @@
+# Magic Eight Ball
+
+A minimal example of hosting a GraphQL schema with the `FSharp.Data.GraphQL.Server.Suave` package.
+
+## Running
+
+```bash
+dotnet run --project samples/magic-eight-ball/magic-eight-ball.fsproj
+```
+
+The server listens on `http://localhost:8080` (Suave's `defaultConfig`). Ask it a question:
+
+```bash
+curl http://localhost:8080 \
+    -H "Content-Type: application/json" \
+    -d '{ "query": "{ ask(question: \"Will it build?\") }" }'
+```
+
+Or open [http://localhost:8080/graphiql](http://localhost:8080/graphiql) to ask it from the GraphiQL IDE. 
+
+## Subscriptions (WebSockets)
+
+The `shake` mutation notifies anyone subscribed to `onShake` with the new answer, over the `graphql-transport-ws`
+protocol at `ws://localhost:8080/ws`. Open two tabs of the GraphiQL IDE above to see it live: run
+
+```graphql
+subscription { onShake }
+```
+
+in one, then run
+
+```graphql
+mutation { shake }
+```
+
+in the other - the answer shows up in the first tab as soon as it's published.
diff --git a/samples/magic-eight-ball/Schema.fs b/samples/magic-eight-ball/Schema.fs
new file mode 100644
index 00000000..34b8773d
--- /dev/null
+++ b/samples/magic-eight-ball/Schema.fs
@@ -0,0 +1,78 @@
+module FSharp.Data.GraphQL.Samples.MagicEightBall.Schema
+
+open System
+open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Types
+
+let private answers = [|
+    "It is certain."
+    "It is decidedly so."
+    "Without a doubt."
+    "Yes, definitely."
+    "You may rely on it."
+    "As I see it, yes."
+    "Most likely."
+    "Outlook good."
+    "Yes."
+    "Signs point to yes."
+    "Reply hazy, try again."
+    "Ask again later."
+    "Better not tell you now."
+    "Cannot predict now."
+    "Concentrate and ask again."
+    "Don't count on it."
+    "My reply is no."
+    "My sources say no."
+    "Outlook not so good."
+    "Very doubtful."
+|]
+
+type Root = { Random : Random }
+
+let private shake (random : Random) = answers[random.Next answers.Length]
+
+let Query =
+    Define.Object<Root>(
+        name = "Query",
+        fields = [
+            Define.Field (
+                "ask",
+                StringType,
+                "Shakes the magic eight ball and returns its answer to the given question.",
+                [ Define.Input ("question", StringType) ],
+                fun _ root -> shake (root.Random)
+            )
+        ]
+    )
+
+let Mutation =
+    Define.Object<Root>(
+        name = "Mutation",
+        fields = [
+            Define.Field (
+                "shake",
+                StringType,
+                "Shakes the magic eight ball and notifies everyone subscribed to `onShake` with the new answer.",
+                fun ctx root ->
+                    let answer = shake (root.Random)
+                    ctx.Schema.SubscriptionProvider.Publish<string> "onShake" answer
+                    answer
+            )
+        ]
+    )
+
+let Subscription =
+    Define.SubscriptionObject<Root>(
+        name = "Subscription",
+        fields = [
+            Define.SubscriptionField (
+                "onShake",
+                Query,
+                StringType,
+                "Notified with a new answer whenever anyone shakes the ball via the `shake` mutation.",
+                fun _ _ (answer : string) -> Some answer
+            )
+        ]
+    )
+
+let schema : ISchema<Root> = upcast Schema (Query, Mutation, Subscription)
diff --git a/samples/magic-eight-ball/magic-eight-ball.fsproj b/samples/magic-eight-ball/magic-eight-ball.fsproj
new file mode 100644
index 00000000..ed0257dd
--- /dev/null
+++ b/samples/magic-eight-ball/magic-eight-ball.fsproj
@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>$(DotNetVersion)</TargetFramework>
+    <AssemblyName>FSharp.Data.GraphQL.Samples.MagicEightBall</AssemblyName>
+    <RootNamespace>FSharp.Data.GraphQL.Samples.MagicEightBall</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Referenced only for its embedded GraphiQL page (see GraphiQL.fs) - its middleware is ASP.NET Core-only. -->
+    <PackageReference Include="GraphQL.Server.Ui.GraphiQL" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Include="Schema.fs" />
+    <Compile Include="GraphiQL.fs" />
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\FSharp.Data.GraphQL.Server.Suave\FSharp.Data.GraphQL.Server.Suave.fsproj" />
+    <ProjectReference Include="..\..\src\FSharp.Data.GraphQL.Server\FSharp.Data.GraphQL.Server.fsproj" />
+    <ProjectReference Include="..\..\src\FSharp.Data.GraphQL.Shared\FSharp.Data.GraphQL.Shared.fsproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/FSharp.Data.GraphQL.Server.Middleware/DefineExtensions.fs b/src/FSharp.Data.GraphQL.Server.Middleware/DefineExtensions.fs
index eb2af4a6..b7f6c899 100644
--- a/src/FSharp.Data.GraphQL.Server.Middleware/DefineExtensions.fs
+++ b/src/FSharp.Data.GraphQL.Server.Middleware/DefineExtensions.fs
@@ -18,8 +18,8 @@ module DefineExtensions =
         /// A boolean flag indicating if the values of the threshold and the weight of the current query should
         /// be reported to the metadata object in the GQLResponse.
         /// </param>
-        static member QueryWeightMiddleware(threshold : float, ?reportToMetadata : bool) : IExecutorMiddleware =
-            let reportToMetadata = defaultArg reportToMetadata false
+        static member QueryWeightMiddleware(threshold : float, [<Struct>] ?reportToMetadata : bool) : IExecutorMiddleware =
+            let reportToMetadata = defaultValueArg reportToMetadata false
             upcast QueryWeightMiddleware(threshold, reportToMetadata)
 
         /// <summary>
@@ -35,8 +35,8 @@ module DefineExtensions =
         /// This argument can be used on the query to specify a filter with operations like "less than", "equals", etc. on the
         /// field of the specified object of 'ObjectType type.
         /// </remarks>
-        static member ObjectListFilterMiddleware<'ObjectType, 'ListType>(?reportToMetadata : bool) : IExecutorMiddleware =
-            let reportToMetadata = defaultArg reportToMetadata false
+        static member ObjectListFilterMiddleware<'ObjectType, 'ListType>([<Struct>] ?reportToMetadata : bool) : IExecutorMiddleware =
+            let reportToMetadata = defaultValueArg reportToMetadata false
             upcast ObjectListFilterMiddleware<'ObjectType, 'ListType>(reportToMetadata)
 
         /// <summary>
@@ -47,6 +47,6 @@ module DefineExtensions =
         /// An optional function to resolve the name of the identity field based on the object definition.
         /// If no function is provided, it takes the default "Id" value as the identity field.
         /// </param>
-        static member LiveQueryMiddleware(?identityName : IdentityNameResolver) : IExecutorMiddleware =
-            let identityName = defaultArg identityName (fun _ -> "Id")
+        static member LiveQueryMiddleware([<Struct>] ?identityName : IdentityNameResolver) : IExecutorMiddleware =
+            let identityName = defaultValueArg identityName (fun _ -> "Id")
             upcast LiveQueryMiddleware(identityName)
diff --git a/src/FSharp.Data.GraphQL.Server.Middleware/MiddlewareDefinitions.fs b/src/FSharp.Data.GraphQL.Server.Middleware/MiddlewareDefinitions.fs
index 6d0f182c..4aae7f4a 100644
--- a/src/FSharp.Data.GraphQL.Server.Middleware/MiddlewareDefinitions.fs
+++ b/src/FSharp.Data.GraphQL.Server.Middleware/MiddlewareDefinitions.fs
@@ -76,10 +76,10 @@ type internal QueryWeightMiddleware (threshold : float, reportToMetadata : bool)
         if pass then next ctx else error ctx
 
     interface IExecutorMiddleware with
-        member _.CompileSchema = None
-        member _.PostCompileSchema = None
-        member _.PlanOperation = None
-        member _.ExecuteOperationAsync = Some (middleware threshold)
+        member _.CompileSchema = ValueNone
+        member _.PostCompileSchema = ValueNone
+        member _.PlanOperation = ValueNone
+        member _.ExecuteOperationAsync = ValueSome (middleware threshold)
 
 type internal ObjectListFilterMiddleware<'ObjectType, 'ListType> (reportToMetadata : bool) =
 
@@ -153,10 +153,10 @@ type internal ObjectListFilterMiddleware<'ObjectType, 'ListType> (reportToMetada
             return GQLExecutionResult.RequestError (ctx.ExecutionPlan.DocumentId, (errs |> List.map GQLProblemDetails.OfError), ctx.Metadata)
           }
     interface IExecutorMiddleware with
-        member _.CompileSchema = Some compileMiddleware
-        member _.PostCompileSchema = None
-        member _.PlanOperation = None
-        member _.ExecuteOperationAsync = Some reportMiddleware
+        member _.CompileSchema = ValueSome compileMiddleware
+        member _.PostCompileSchema = ValueNone
+        member _.PlanOperation = ValueNone
+        member _.ExecuteOperationAsync = ValueSome reportMiddleware
 
 /// A function that resolves an identity name for a schema object, based on a object definition of it.
 type IdentityNameResolver = ObjectDef -> string
@@ -203,7 +203,7 @@ type internal LiveQueryMiddleware (identityNameResolver : IdentityNameResolver)
         next ctx
 
     interface IExecutorMiddleware with
-        member _.CompileSchema = Some middleware
-        member _.PostCompileSchema = None
-        member _.PlanOperation = None
-        member _.ExecuteOperationAsync = None
+        member _.CompileSchema = ValueSome middleware
+        member _.PostCompileSchema = ValueNone
+        member _.PlanOperation = ValueNone
+        member _.ExecuteOperationAsync = ValueNone
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/FSharp.Data.GraphQL.Server.Suave.fsproj b/src/FSharp.Data.GraphQL.Server.Suave/FSharp.Data.GraphQL.Server.Suave.fsproj
new file mode 100644
index 00000000..4c8e79ea
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/FSharp.Data.GraphQL.Server.Suave.fsproj
@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>$(DotNetVersion)</TargetFrameworks>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <Deterministic>true</Deterministic>
+    <Description>FSharp implementation of Facebook GraphQL query language (Suave integration)</Description>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="GraphQLOptions.fs" />
+    <Compile Include="SuaveInputExecutionContext.fs" />
+    <Compile Include="RequestParsing.fs" />
+    <Compile Include="GraphQLHttpHandler.fs" />
+    <Compile Include="GraphQLSubscriptionsManagement.fs" />
+    <Compile Include="GraphQLWebSocketHandler.fs" />
+    <Compile Include="GraphQL.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Condition="$(IsNuGet) == ''" Include="..\FSharp.Data.GraphQL.Shared\FSharp.Data.GraphQL.Shared.fsproj" />
+    <ProjectReference Condition="$(IsNuGet) == ''" Include="..\FSharp.Data.GraphQL.Server\FSharp.Data.GraphQL.Server.fsproj" />
+    <PackageReference Condition="$(IsNuGet) != ''" Include="FSharp.Data.GraphQL.Shared" VersionOverride="$(Version)" />
+    <PackageReference Condition="$(IsNuGet) != ''" Include="FSharp.Data.GraphQL.Server" VersionOverride="$(Version)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FsToolkit.ErrorHandling" />
+    <PackageReference Include="Suave" />
+  </ItemGroup>
+
+</Project>
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/GraphQL.fs b/src/FSharp.Data.GraphQL.Server.Suave/GraphQL.fs
new file mode 100644
index 00000000..5d2bf122
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/GraphQL.fs
@@ -0,0 +1,33 @@
+/// <summary>
+/// Suave <see cref="Suave.Http.WebPart"/>s that serve a GraphQL schema over HTTP and, for subscriptions, over the
+/// <c>graphql-transport-ws</c> WebSocket protocol.
+/// </summary>
+module FSharp.Data.GraphQL.Server.Suave.GraphQL
+
+open Suave
+open Suave.Http
+open Suave.Operators
+
+open FSharp.Data.GraphQL
+
+/// <summary>
+/// Builds a <see cref="Suave.Http.WebPart"/> that serves GraphQL queries, mutations and introspection over HTTP
+/// (<c>GET</c> and <c>POST</c>, including the GraphQL multipart request specification for file uploads), and
+/// GraphQL subscriptions over the <c>graphql-transport-ws</c> WebSocket protocol, at the WebSocket endpoint
+/// configured in <paramref name="options"/>.
+/// </summary>
+let graphQLWithOptions (options : GraphQLOptions<'Root>) : WebPart =
+    choose [
+        Filters.path options.WebsocketOptions.EndpointUrl
+        >=> GraphQLWebSocketHandler.handleGraphQLWebSocket options
+        (Filters.GET <|> Filters.POST)
+        >=> GraphQLHttpHandler.handleGraphQL options
+    ]
+
+/// <summary>
+/// Builds a <see cref="Suave.Http.WebPart"/> that serves GraphQL queries, mutations, introspection and (over the
+/// <c>graphql-transport-ws</c> WebSocket protocol, at the default <c>/ws</c> endpoint) subscriptions, for the given
+/// schema executor and root value factory.
+/// </summary>
+let graphQL (executor : Executor<'Root>) (rootFactory : HttpContext -> 'Root) : WebPart =
+    graphQLWithOptions (GraphQLOptions.create executor rootFactory)
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/GraphQLHttpHandler.fs b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLHttpHandler.fs
new file mode 100644
index 00000000..5203f448
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLHttpHandler.fs
@@ -0,0 +1,75 @@
+module internal FSharp.Data.GraphQL.Server.Suave.GraphQLHttpHandler
+
+open System.Text.Json
+open System.Text.Json.Serialization
+open Suave
+open Suave.Http
+open Suave.Operators
+open Suave.Utils
+
+open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Shared
+
+let private jsonMimeType = "application/json; charset=utf-8"
+
+let private jsonResponse (serializerOptions : JsonSerializerOptions) (statusCode : HttpCode) (value : 'T) : WebPart =
+    let json = JsonSerializer.Serialize (value, serializerOptions)
+    Writers.setMimeType jsonMimeType
+    >=> Response.response statusCode (UTF8.bytes json)
+
+let private toResponse ({ DocumentId = documentId; Content = content } : GQLExecutionResult) =
+    match content with
+    // `GQLResponse` carries a null `data` for a result whose non-null root field failed
+    | Direct (data, errs) -> GQLResponse.Direct (documentId, data |> ValueOption.toObj, errs)
+    | Deferred (data, errs, _deferred) -> GQLResponse.Direct (documentId, data, errs)
+    | Stream _stream -> GQLResponse.Stream documentId
+    | RequestError errs -> GQLResponse.RequestError (documentId, errs)
+
+let private executeIntrospectionQuery (options : GraphQLOptions<'Root>) (ctx : HttpContext) (ast : Ast.Document voption) : Async<GQLResponse> = async {
+    let getInputContext () = SuaveInputExecutionContext (ctx.request) :> IInputExecutionContext
+    let executor = options.SchemaExecutor
+
+    let! result =
+        match ast with
+        | ValueNone -> executor.AsyncExecute (IntrospectionQuery.Definition, getInputContext)
+        | ValueSome ast -> executor.AsyncExecute (ast, getInputContext)
+
+    return toResponse result
+}
+
+let private executeOperation (options : GraphQLOptions<'Root>) (ctx : HttpContext) (content : ParsedGQLQueryRequestContent) : Async<GQLResponse> =
+    async {
+        let getInputContext () = SuaveInputExecutionContext (ctx.request) :> IInputExecutionContext
+
+        let operationName =
+            content.OperationName
+            |> Skippable.filter (not << isNull)
+            |> Skippable.toValueOption
+
+        let variables =
+            content.Variables
+            |> Skippable.filter (not << isNull)
+            |> Skippable.toValueOption
+
+        let root = options.RootFactory ctx
+
+        let! result =
+            options.SchemaExecutor.AsyncExecute (content.Ast, getInputContext, root, ?variables = variables, ?operationName = operationName)
+
+        return toResponse result
+    }
+
+/// A <see cref="Suave.Http.WebPart"/> that parses and executes GraphQL requests over HTTP (both <c>GET</c> introspection
+/// queries and <c>POST</c> queries/mutations, including the GraphQL multipart request specification for file uploads).
+let handleGraphQL (options : GraphQLOptions<'Root>) : WebPart =
+    fun (ctx : HttpContext) -> async {
+        match RequestParsing.checkOperationType options.SerializerOptions ctx.request with
+        | Ok (IntrospectionQuery ast) ->
+            let! response = executeIntrospectionQuery options ctx ast
+            return! jsonResponse options.SerializerOptions HTTP_200 response ctx
+        | Ok (OperationQuery content) ->
+            let! response = executeOperation options ctx content
+            return! jsonResponse options.SerializerOptions HTTP_200 response ctx
+        | Error errorMessage ->
+            return! jsonResponse options.SerializerOptions HTTP_400 (GQLResponse.RequestError (0, [ GQLProblemDetails.Create errorMessage ])) ctx
+    }
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/GraphQLOptions.fs b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLOptions.fs
new file mode 100644
index 00000000..1dc06d15
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLOptions.fs
@@ -0,0 +1,64 @@
+namespace FSharp.Data.GraphQL.Server.Suave
+
+open System
+open System.Text.Json
+open Suave.Http
+
+open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Shared
+
+/// A custom handler invoked for the <c>ping</c>/<c>pong</c> messages of the <c>graphql-transport-ws</c> protocol.
+type PingHandler = JsonDocument voption -> Async<JsonDocument voption>
+
+/// Default values used to configure <see cref="GraphQLOptions{Root}"/>.
+[<RequireQualifiedAccess>]
+module GraphQLOptionsDefaults =
+
+    /// The default path at which <c>graphql-transport-ws</c> WebSocket connections are accepted.
+    [<Literal>]
+    let WebSocketEndpoint = "/ws"
+
+    /// The default timeout, in milliseconds, to wait for a <c>connection_init</c> message before closing the socket.
+    [<Literal>]
+    let WebSocketConnectionInitTimeoutInMs = 3000.0
+
+/// <summary>Options that configure the <c>graphql-transport-ws</c> WebSocket protocol.</summary>
+[<NoComparison>]
+[<NoEquality>]
+type GraphQLTransportWSOptions = {
+    /// <summary>The path at which WebSocket connections for GraphQL subscriptions are accepted.</summary>
+    EndpointUrl : string
+    /// <summary>How long to wait for a <c>connection_init</c> message from the client before closing the socket.</summary>
+    ConnectionInitTimeout : TimeSpan
+    /// <summary>An optional custom handler invoked for <c>ping</c>/<c>pong</c> messages.</summary>
+    CustomPingHandler : PingHandler voption
+}
+
+/// <summary>Options used to configure the GraphQL <see cref="Suave.Http.WebPart"/>s exposed by this library.</summary>
+[<NoComparison>]
+[<NoEquality>]
+type GraphQLOptions<'Root> = {
+    /// <summary>The schema executor used to run GraphQL operations.</summary>
+    SchemaExecutor : Executor<'Root>
+    /// <summary>Builds the root value used to execute a GraphQL operation from the current <see cref="Suave.Http.HttpContext"/>.</summary>
+    RootFactory : HttpContext -> 'Root
+    /// <summary>The <see cref="System.Text.Json.JsonSerializerOptions"/> used to (de)serialize GraphQL requests, responses and WebSocket messages.</summary>
+    SerializerOptions : JsonSerializerOptions
+    /// <summary>Options for the <c>graphql-transport-ws</c> WebSocket protocol.</summary>
+    WebsocketOptions : GraphQLTransportWSOptions
+}
+
+/// <summary>Functions to create <see cref="GraphQLOptions{Root}"/>.</summary>
+module GraphQLOptions =
+
+    /// <summary>Creates <see cref="GraphQLOptions{Root}"/> with default settings for the given executor and root factory.</summary>
+    let create (executor : Executor<'Root>) (rootFactory : HttpContext -> 'Root) : GraphQLOptions<'Root> = {
+        SchemaExecutor = executor
+        RootFactory = rootFactory
+        SerializerOptions = Json.getWSSerializerOptions Seq.empty
+        WebsocketOptions = {
+            EndpointUrl = GraphQLOptionsDefaults.WebSocketEndpoint
+            ConnectionInitTimeout = TimeSpan.FromMilliseconds GraphQLOptionsDefaults.WebSocketConnectionInitTimeoutInMs
+            CustomPingHandler = ValueNone
+        }
+    }
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/GraphQLSubscriptionsManagement.fs b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLSubscriptionsManagement.fs
new file mode 100644
index 00000000..33f2281c
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLSubscriptionsManagement.fs
@@ -0,0 +1,37 @@
+module internal FSharp.Data.GraphQL.Server.Suave.GraphQLSubscriptionsManagement
+
+open System
+open System.Collections.Generic
+
+open FSharp.Data.GraphQL.Shared.WebSockets
+
+/// The active subscriptions of one connection, keyed by the id the client gave each of them, with the handle that
+/// unsubscribes from its source.
+type SubscriptionsDict = Dictionary<SubscriptionId, IDisposable>
+
+// `subscriptions` is mutated both from the WebSocket's sequential message loop and from the `IObserver` callbacks of
+// each active subscription's stream, which can fire on an arbitrary thread. `Dictionary` is not safe for concurrent
+// access, so every operation here locks on the dictionary instance itself - the same instance is shared by every
+// caller for a given connection, so this serializes all of them against each other.
+let createSubscriptions () = SubscriptionsDict (StringComparer.Ordinal)
+
+let addSubscription (id : SubscriptionId, unsubscriber : IDisposable) (subscriptions : SubscriptionsDict) =
+    lock subscriptions (fun () -> subscriptions.Add (id, unsubscriber))
+
+let isIdTaken (id : SubscriptionId) (subscriptions : SubscriptionsDict) = lock subscriptions (fun () -> subscriptions.ContainsKey id)
+
+let removeSubscription (id : SubscriptionId) (subscriptions : SubscriptionsDict) =
+    lock subscriptions (fun () ->
+        match subscriptions.TryGetValue id with
+        | true, unsubscriber ->
+            subscriptions.Remove id |> ignore
+            unsubscriber.Dispose ()
+        | false, _ -> ())
+
+let removeAllSubscriptions (subscriptions : SubscriptionsDict) =
+    lock subscriptions (fun () ->
+        try
+            for unsubscriber in subscriptions.Values do
+                unsubscriber.Dispose ()
+        finally
+            subscriptions.Clear ())
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/GraphQLWebSocketHandler.fs b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLWebSocketHandler.fs
new file mode 100644
index 00000000..086d32d1
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/GraphQLWebSocketHandler.fs
@@ -0,0 +1,300 @@
+module internal FSharp.Data.GraphQL.Server.Suave.GraphQLWebSocketHandler
+
+open System
+open System.Collections.Generic
+open System.Text
+open System.Text.Json
+open System.Text.Json.Serialization
+
+open Suave
+open Suave.Http
+open Suave.Logging
+open Suave.Sockets
+open Suave.WebSocket
+
+open FSharp.Data.GraphQL
+open FSharp.Data.GraphQL.Execution
+open FSharp.Data.GraphQL.Shared
+open FSharp.Data.GraphQL.Shared.WebSockets
+
+/// The <c>graphql-transport-ws</c> subprotocol, as defined by
+/// <see href="https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md">the graphql-ws protocol specification</see>.
+[<Literal>]
+let private Subprotocol = "graphql-transport-ws"
+
+let private serializeServerMessage (serializerOptions : JsonSerializerOptions) (serverMessage : ServerMessage) : string =
+    let raw : RawServerMessage =
+        match serverMessage with
+        | ConnectionAck -> { Id = ValueNone; Type = "connection_ack"; Payload = ValueNone }
+        | ServerPing -> { Id = ValueNone; Type = "ping"; Payload = ValueNone }
+        | ServerPong p -> { Id = ValueNone; Type = "pong"; Payload = p |> ValueOption.map CustomResponse }
+        | Next (id, payload) -> {
+            Id = ValueSome id
+            Type = "next"
+            Payload = ValueSome (ExecutionResult payload)
+          }
+        | Complete id -> { Id = ValueSome id; Type = "complete"; Payload = ValueNone }
+        | ServerError (id, errMessages) -> {
+            Id = ValueSome id
+            Type = "error"
+            Payload = ValueSome (ErrorMessages errMessages)
+          }
+
+    JsonSerializer.Serialize (raw, serializerOptions)
+
+let private invalidJsonInClientMessageError = InvalidMessage (4400, "Invalid json in client message")
+
+let private deserializeClientMessage
+    (serializerOptions : JsonSerializerOptions)
+    (bytes : byte[])
+    : Result<ClientMessage, ClientMessageProtocolFailure> =
+    try
+        Ok (JsonSerializer.Deserialize<ClientMessage>(bytes, serializerOptions))
+    with
+    | :? InvalidWebsocketMessageException as ex -> Result.Error (InvalidMessage (4400, ex.Message))
+    | :? JsonException -> Result.Error invalidJsonInClientMessageError
+
+let private sendMessage (serializerOptions : JsonSerializerOptions) (webSocket : WebSocket) (message : ServerMessage) : Async<unit> = async {
+    let bytes =
+        message
+        |> serializeServerMessage serializerOptions
+        |> Encoding.UTF8.GetBytes
+    let! _ = webSocket.send Text (ArraySegment bytes) true
+    ()
+}
+
+let private closeSocket (webSocket : WebSocket) (code : int) (reason : string) : Async<unit> = async {
+    let codeBytes =
+        let bytes = BitConverter.GetBytes (uint16 code)
+        if BitConverter.IsLittleEndian then
+            Array.rev bytes
+        else
+            bytes
+
+    let payload = Array.append codeBytes (Encoding.UTF8.GetBytes reason)
+    let! _ = webSocket.send Close (ArraySegment payload) true
+    ()
+}
+
+let private closeSocketNormally (webSocket : WebSocket) = closeSocket webSocket CloseCode.CLOSE_NORMAL.code "Normal Closure"
+
+/// Awaits the given computation, giving up (and returning <see langword="None"/>) after the given timeout has elapsed.
+let private withTimeout (timeout : TimeSpan) (computation : Async<'T>) : Async<'T option> = async {
+    let! child = Async.StartChild (computation, int timeout.TotalMilliseconds)
+
+    try
+        let! result = child
+        return Some result
+    with :? TimeoutException ->
+        return None
+}
+
+[<Struct>]
+type private RawFrame =
+    | FrameData of byte[]
+    | FrameClosed
+
+let rec private readFullFrame (webSocket : WebSocket) (acc : byte[] list) : Async<RawFrame> = async {
+    let! frame = webSocket.read ()
+
+    match frame with
+    | Choice1Of2 (Close, _, _) -> return FrameClosed
+    | Choice1Of2 (Ping, _, _)
+    | Choice1Of2 (Pong, _, _) -> return! readFullFrame webSocket acc
+    | Choice1Of2 (_, data, fin) ->
+        let acc = data :: acc
+        if fin then
+            return FrameData (acc |> List.rev |> Array.concat)
+        else
+            return! readFullFrame webSocket acc
+    | Choice2Of2 _error -> return FrameClosed
+}
+
+type private ReceivedMessage =
+    | ClientMsg of ClientMessage
+    | ProtocolFailure of ClientMessageProtocolFailure
+    | NoOp
+    | SocketClosed
+
+let private receiveMessage (serializerOptions : JsonSerializerOptions) (webSocket : WebSocket) : Async<ReceivedMessage> = async {
+    let! frame = readFullFrame webSocket []
+
+    match frame with
+    | FrameClosed -> return SocketClosed
+    | FrameData bytes when bytes.Length = 0 -> return NoOp
+    | FrameData bytes ->
+        match deserializeClientMessage serializerOptions bytes with
+        | Ok msg -> return ClientMsg msg
+        | Result.Error failure -> return ProtocolFailure failure
+}
+
+/// Waits for a <c>connection_init</c> message and acknowledges it, per the <c>graphql-transport-ws</c> protocol.
+let private waitForConnectionInitAndRespondToClient (options : GraphQLOptions<'Root>) (webSocket : WebSocket) : Async<Result<unit, string>> = async {
+    let! received =
+        withTimeout options.WebsocketOptions.ConnectionInitTimeout (receiveMessage options.SerializerOptions webSocket)
+
+    match received with
+    | None ->
+        do! closeSocket webSocket CustomWebSocketStatus.ConnectionTimeout "Connection initialization timeout"
+        return Result.Error $"{nameof ConnectionInit} timeout"
+    | Some (ClientMsg (ConnectionInit _)) ->
+        do! sendMessage options.SerializerOptions webSocket ConnectionAck
+        return Ok ()
+    | Some (ClientMsg (Subscribe _)) ->
+        do! closeSocket webSocket CustomWebSocketStatus.Unauthorized "Unauthorized"
+        return Result.Error "Unauthorized"
+    | Some (ProtocolFailure (InvalidMessage (code, explanation))) ->
+        do! closeSocket webSocket code explanation
+        return Result.Error explanation
+    | Some _ ->
+        do! closeSocketNormally webSocket
+        return Result.Error $"{nameof ConnectionInit} failed (not because of timeout)"
+}
+
+/// <summary>
+/// Converts an exception raised by a subscription's source into the errors of its terminal <c>error</c> message,
+/// exposing only messages of GraphQL-facing errors.
+/// </summary>
+let private problemDetailsOfSourceError (ex : exn) : GQLProblemDetails list =
+    match box ex with
+    | :? IGQLError as error -> [ GQLProblemDetails.OfError error ]
+    | _ -> [ GQLProblemDetails.Create "Unexpected error during subscription" ]
+
+/// Runs the <c>graphql-transport-ws</c> message loop for an already-initialized connection.
+let private handleMessages (options : GraphQLOptions<'Root>) (ctx : HttpContext) (webSocket : WebSocket) : Async<unit> =
+    let serializerOptions = options.SerializerOptions
+    let subscriptions = GraphQLSubscriptionsManagement.createSubscriptions ()
+    let sendMsg msg = sendMessage serializerOptions webSocket msg
+
+    let sendOutput id (output : SubscriptionExecutionResult) = sendMsg (Next (id, output))
+
+    let sendSubscriptionResponseOutput id subscriptionResult =
+        match subscriptionResult with
+        | SubscriptionResult output -> sendOutput id (SubscriptionExecutionResult.Create (ValueSome output, []))
+        // The executor may still have resolved partial data alongside the field errors; it is forwarded as-is
+        | SubscriptionErrors (ValueSome output, errors) -> sendOutput id (SubscriptionExecutionResult.Create (ValueSome output, errors))
+        | SubscriptionErrors (ValueNone, errors) -> sendOutput id (SubscriptionExecutionResult.CreateErrors errors)
+
+    let addClientSubscription
+        (id : SubscriptionId)
+        (howToSendDataOnNext : SubscriptionId -> 'ResponseContent -> Async<unit>)
+        (streamSource : IObservable<'ResponseContent>)
+        =
+        // Set once the source has ended, so that a source ending synchronously inside `Subscribe` does not leave its id
+        // registered after the end has already tried to remove it
+        let mutable ended = false
+
+        let endSubscription (message : ServerMessage) =
+            ended <- true
+            sendMsg message |> Async.RunSynchronously
+            subscriptions
+            |> GraphQLSubscriptionsManagement.removeSubscription id
+
+        let observer = {
+            new IObserver<'ResponseContent> with
+                member _.OnNext value = howToSendDataOnNext id value |> Async.RunSynchronously
+                member _.OnError ex =
+                    ctx.runtime.logger.info (Suave.Logging.Message.eventX $"Error on subscription with Id = '{id}': {ex}")
+                    endSubscription (ServerError (id, problemDetailsOfSourceError ex))
+                member _.OnCompleted () = endSubscription (Complete id)
+        }
+
+        let unsubscriber = streamSource.Subscribe observer
+        lock subscriptions (fun () ->
+            if ended then
+                unsubscriber.Dispose ()
+            else
+                subscriptions
+                |> GraphQLSubscriptionsManagement.addSubscription (id, unsubscriber))
+
+    let applyPlanExecutionResult (id : SubscriptionId) (executionResult : GQLExecutionResult) = async {
+        match executionResult.Content with
+        | Stream observableOutput ->
+            observableOutput
+            |> addClientSubscription id sendSubscriptionResponseOutput
+        | Deferred (data, errors, _deferred) ->
+            // TODO: deliver the deferred and streamed payloads in the incremental delivery format, as the ASP.NET Core
+            // integration does through its `IncrementalDelivery`; until then only the initial result is sent
+            do! sendOutput id (SubscriptionExecutionResult.Create (ValueSome data, errors))
+            do! sendMsg (Complete id)
+        | Direct (data, errors) ->
+            // An execution result, whose data is null when a non-null root field failed during execution; still a
+            // result, so it is sent as Next + Complete like any other, not as the terminal Error
+            do! sendOutput id (SubscriptionExecutionResult.Create (data, errors))
+            // The graphql-transport-ws protocol requires Complete after the single Next of a query or mutation
+            do! sendMsg (Complete id)
+        | RequestError problemDetails ->
+            // The request was rejected before execution, so it is not a result: the protocol requires it to be sent
+            // as the terminal Error message instead of a Next followed by Complete
+            do! sendMsg (ServerError (id, problemDetails))
+    }
+
+    let handleSubscribe (id : SubscriptionId) (query : GQLRequestContent) = async {
+        if subscriptions |> GraphQLSubscriptionsManagement.isIdTaken id then
+            do! closeSocket webSocket CustomWebSocketStatus.SubscriberAlreadyExists $"Subscriber for Id = '{id}' already exists"
+        else
+            try
+                let variables = query.Variables |> Skippable.toValueOption
+                let getInputContext () = SuaveInputExecutionContext (ctx.request) :> IInputExecutionContext
+                let root = options.RootFactory ctx
+                let! planExecutionResult =
+                    options.SchemaExecutor.AsyncExecute (query.Query, getInputContext, root, ?variables = variables)
+                do! applyPlanExecutionResult id planExecutionResult
+            with ex ->
+                ctx.runtime.logger.info (Suave.Logging.Message.eventX $"Unexpected error during subscription with id '{id}': {ex}")
+                do! sendMsg (ServerError (id, [ GQLProblemDetails.Create "Unexpected error during subscription" ]))
+    }
+
+    let rec loop () = async {
+        let! received = receiveMessage serializerOptions webSocket
+
+        match received with
+        | SocketClosed -> return ()
+        | NoOp -> return! loop ()
+        | ProtocolFailure (InvalidMessage (code, explanation)) ->
+            do! closeSocket webSocket code explanation
+            return ()
+        | ClientMsg (ConnectionInit _) ->
+            do! closeSocket webSocket CustomWebSocketStatus.TooManyInitializationRequests "Too many initialization requests"
+            return ()
+        | ClientMsg (ClientPing p) ->
+            match options.WebsocketOptions.CustomPingHandler with
+            | ValueSome handler ->
+                let! customP = handler p
+                do! sendMsg (ServerPong customP)
+            | ValueNone -> do! sendMsg (ServerPong p)
+            return! loop ()
+        | ClientMsg (ClientPong _) -> return! loop ()
+        | ClientMsg (Subscribe (id, query)) ->
+            do! handleSubscribe id query
+            return! loop ()
+        | ClientMsg (ClientComplete id) ->
+            subscriptions
+            |> GraphQLSubscriptionsManagement.removeSubscription id
+            return! loop ()
+    }
+
+    async {
+        try
+            do! loop ()
+        finally
+            subscriptions
+            |> GraphQLSubscriptionsManagement.removeAllSubscriptions
+    }
+
+/// A <see cref="Suave.Http.WebPart"/> that accepts <c>graphql-transport-ws</c> WebSocket connections and handles
+/// GraphQL subscriptions (as well as queries and mutations) over them.
+let handleGraphQLWebSocket (options : GraphQLOptions<'Root>) : WebPart =
+    fun (ctx : HttpContext) ->
+        let continuation (webSocket : WebSocket) (ctx : HttpContext) : SocketOp<unit> =
+            SocketOp.ofAsync (
+                async {
+                    let! initResult = waitForConnectionInitAndRespondToClient options webSocket
+
+                    match initResult with
+                    | Result.Error _ -> ()
+                    | Ok () -> do! handleMessages options ctx webSocket
+                }
+            )
+
+        handShakeWithSubprotocol (chooseSubprotocol Subprotocol) continuation ctx
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/README.md b/src/FSharp.Data.GraphQL.Server.Suave/README.md
new file mode 100644
index 00000000..67093e6b
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/README.md
@@ -0,0 +1,77 @@
+## Usage
+
+### Server
+
+```fsharp
+open Suave
+open FSharp.Data.GraphQL.Server.Suave
+
+// Factory for object holding request-wide info. You define Root somewhere else.
+let rootFactory (_ctx : Http.HttpContext) : Root =
+    { RequestId = System.Guid.NewGuid().ToString() }
+
+// --> Schema.executor is defined by yourself somewhere else (in another file)
+let app : WebPart = GraphQL.graphQL Schema.executor rootFactory
+
+startWebServer defaultConfig app
+```
+
+This single `WebPart` serves GraphQL queries, mutations and introspection for every `GET`/`POST` request it
+receives (including the GraphQL multipart request specification for file uploads), and accepts
+`graphql-transport-ws` WebSocket connections (used for subscriptions) at `/ws` by default. Compose it with Suave's
+usual routing combinators (`path`, `pathStarts`, `choose`, ...) the way you would any other `WebPart` – just make
+sure the WebSocket endpoint configured in `GraphQLOptions.WebsocketOptions.EndpointUrl` (an absolute path) is
+still reachable through whatever routing you put in front of it.
+
+To customize the WebSocket endpoint path, the connection init timeout, a custom `ping`/`pong` handler or the
+JSON serializer options, build a `GraphQLOptions<'Root>` and call `GraphQL.graphQLWithOptions` instead:
+
+```fsharp
+let defaultOptions = GraphQLOptions.create Schema.executor rootFactory
+
+let options =
+    { defaultOptions with
+        WebsocketOptions = { defaultOptions.WebsocketOptions with EndpointUrl = "/subscriptions" } }
+
+let app : WebPart = GraphQL.graphQLWithOptions options
+```
+
+In your schema, you'll want to define a subscription, like in (example taken from the star-wars-api sample in the "samples/" folder):
+
+```fsharp
+    let Subscription =
+        Define.SubscriptionObject<Root>(
+            name = "Subscription",
+            fields = [
+                Define.SubscriptionField(
+                    "watchMoon",
+                    RootType,
+                    PlanetType,
+                    "Watches to see if a planet is a moon.",
+                    [ Define.Input("id", StringType) ],
+                    (fun ctx _ p -> if ctx.Arg("id") = p.Id then Some p else None)) ])
+```
+
+Don't forget to notify subscribers about new values:
+
+```fsharp
+    let Mutation =
+        Define.Object<Root>(
+            name = "Mutation",
+            fields = [
+                Define.Field(
+                    "setMoon",
+                    Nullable PlanetType,
+                    "Defines if a planet is actually a moon or not.",
+                    [ Define.Input("id", StringType); Define.Input("isMoon", BooleanType) ],
+                    fun ctx _ ->
+                        getPlanet (ctx.Arg("id"))
+                        |> Option.map (fun x ->
+                            x.SetMoon(Some(ctx.Arg("isMoon"))) |> ignore
+                            schemaConfig.SubscriptionProvider.Publish<Planet> "watchMoon" x // here you notify the subscribers upon a mutation
+                            x))])
+```
+
+### Client
+
+Using your favorite (or not :)) client library (e.g.: [Apollo Client](https://www.apollographql.com/docs/react/get-started), [Relay](https://relay.dev), [Strawberry Shake](https://chillicream.com/docs/strawberryshake/v13), [elm-graphql](https://github.com/dillonkearns/elm-graphql) ❤️), just point to your server's address (`localhost:8080` for `defaultConfig`, as per the example above) and, as long as the client implements the `graphql-transport-ws` subprotocol, subscriptions should work.
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/RequestParsing.fs b/src/FSharp.Data.GraphQL.Server.Suave/RequestParsing.fs
new file mode 100644
index 00000000..cf894146
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/RequestParsing.fs
@@ -0,0 +1,85 @@
+module internal FSharp.Data.GraphQL.Server.Suave.RequestParsing
+
+open System.Text
+open System.Text.Json
+open System.Text.Json.Serialization
+open FsToolkit.ErrorHandling
+open Suave.Http
+
+open FSharp.Data.GraphQL.Shared
+
+module ServerAst = FSharp.Data.GraphQL.Server.Ast
+
+/// Reads the raw GraphQL request body, honoring the multipart request specification
+/// (the "operations" field carries the GraphQL request when the request is multipart).
+let private hasBody (request : HttpRequest) =
+    request.rawForm.Length > 0
+    || not request.multiPartFields.IsEmpty
+    || not request.files.IsEmpty
+
+let private tryBindGQLRequestContent (serializerOptions : JsonSerializerOptions) (request : HttpRequest) : Result<GQLRequestContent, string> =
+    let json =
+        if request.multiPartFields.IsEmpty then
+            Encoding.UTF8.GetString request.rawForm
+        else
+            request.multiPartFields
+            |> List.tryFind (fst >> (=) "operations")
+            |> Option.map snd
+            |> Option.defaultValue "{}"
+
+    try
+        Ok (JsonSerializer.Deserialize<GQLRequestContent>(json, serializerOptions))
+    with :? JsonException as ex ->
+        Error
+            $"Expected JSON similar to value in '%s{GQLRequestContent.expectedJSON}', but could not parse the received request body. \
+              Error: %s{ex.Message}"
+
+let private parseOrError (query : string) =
+    query
+    |> FSharp.Data.GraphQL.Parser.tryParse
+    |> Result.mapError (fun errorMessage -> $"Cannot parse GraphQL query: %s{errorMessage}")
+
+let private checkAnonymousFieldsOnly (serializerOptions : JsonSerializerOptions) (request : HttpRequest) : Result<OperationType, string> = result {
+    let! gqlRequest = tryBindGQLRequestContent serializerOptions request
+    let! ast = parseOrError gqlRequest.Query
+    let operationName = gqlRequest.OperationName |> Skippable.toValueOption
+
+    let createParsedContent () : ParsedGQLQueryRequestContent = {
+        Query = gqlRequest.Query
+        Ast = ast
+        OperationName = gqlRequest.OperationName
+        Variables = gqlRequest.Variables
+    }
+
+    if ast.IsEmpty then
+        return IntrospectionQuery ValueNone
+    else
+        match ServerAst.tryFindOperationByName operationName ast with
+        | None -> return IntrospectionQuery ValueNone
+        | Some op ->
+            if
+                op.OperationType
+                <> FSharp.Data.GraphQL.Ast.OperationType.Query
+            then
+                return createParsedContent () |> OperationQuery
+            else
+                let hasNonMetaFields = ServerAst.containsFieldsBeyond ServerAst.metaTypeFields ignore ignore op
+
+                if hasNonMetaFields then
+                    return createParsedContent () |> OperationQuery
+                else
+                    return IntrospectionQuery (ValueSome ast)
+}
+
+/// <summary>
+/// Checks if the request is an introspection query by first checking on such properties as
+/// <c>GET</c> method or an empty request body, and lastly by parsing the document AST for an
+/// introspection operation definition.
+/// </summary>
+let checkOperationType (serializerOptions : JsonSerializerOptions) (request : HttpRequest) : Result<OperationType, string> =
+    if request.method = HttpMethod.GET then
+        Ok (IntrospectionQuery ValueNone)
+    elif not (hasBody request) then
+        Ok (IntrospectionQuery ValueNone)
+    else
+        checkAnonymousFieldsOnly serializerOptions request
diff --git a/src/FSharp.Data.GraphQL.Server.Suave/SuaveInputExecutionContext.fs b/src/FSharp.Data.GraphQL.Server.Suave/SuaveInputExecutionContext.fs
new file mode 100644
index 00000000..e3e77c97
--- /dev/null
+++ b/src/FSharp.Data.GraphQL.Server.Suave/SuaveInputExecutionContext.fs
@@ -0,0 +1,30 @@
+namespace FSharp.Data.GraphQL.Server.Suave
+
+open System.IO
+open Suave.Http
+
+open FSharp.Data.GraphQL
+
+/// <summary>
+/// <see cref="IInputExecutionContext"/> implementation that resolves uploaded files from a Suave <see cref="HttpRequest"/>,
+/// following the <see href="https://github.com/jaydenseric/graphql-multipart-request-spec">GraphQL multipart request specification</see>.
+/// </summary>
+type SuaveInputExecutionContext (request : HttpRequest) =
+
+    interface IInputExecutionContext with
+
+        member _.GetFile (key) =
+            match
+                request.files
+                |> List.tryFind (fun file -> file.fieldName = key)
+            with
+            | Some file ->
+                try
+                    let memoryStream = new MemoryStream ()
+                    use fileStream = File.OpenRead file.tempFilePath
+                    fileStream.CopyTo memoryStream
+                    memoryStream.Seek (0L, SeekOrigin.Begin) |> ignore
+                    Ok { FileName = file.fileName; Stream = memoryStream; ContentType = file.mimeType }
+                with ex ->
+                    Error ex.Message
+            | None -> Error $"File with key '%s{key}' not found"
diff --git a/src/FSharp.Data.GraphQL.Server/DefineExtensions.fs b/src/FSharp.Data.GraphQL.Server/DefineExtensions.fs
index 621188c3..f37623db 100644
--- a/src/FSharp.Data.GraphQL.Server/DefineExtensions.fs
+++ b/src/FSharp.Data.GraphQL.Server/DefineExtensions.fs
@@ -14,7 +14,7 @@ module DefineExtensions =
         /// <param name="postCompile">The schema post-compile sub-middleware function.</param>
         /// <param name="plan">The operation planning sub-middleware function.</param>
         /// <param name="execute">The operation execution sub-middleware function.</param>
-        static member ExecutorMiddleware(?compile, ?postCompile, ?plan, ?execute) : IExecutorMiddleware =
+        static member ExecutorMiddleware([<Struct>] ?compile, [<Struct>] ?postCompile, [<Struct>] ?plan, [<Struct>] ?execute) : IExecutorMiddleware =
             { new IExecutorMiddleware with 
                 member _.CompileSchema = compile
                 member _.PostCompileSchema = postCompile
diff --git a/src/FSharp.Data.GraphQL.Server/Executor.fs b/src/FSharp.Data.GraphQL.Server/Executor.fs
index 5fe48700..eb54f0e4 100644
--- a/src/FSharp.Data.GraphQL.Server/Executor.fs
+++ b/src/FSharp.Data.GraphQL.Server/Executor.fs
@@ -42,16 +42,16 @@ type OperationExecutionMiddleware =
 /// A middleware can have one to three sub-middlewares, one for each phase of the query execution.
 type IExecutorMiddleware =
     /// Defines the sub-middleware that intercepts the schema compile process of the Executor.
-    abstract CompileSchema : SchemaCompileMiddleware option
+    abstract CompileSchema : SchemaCompileMiddleware voption
     /// Defines the sub-middleware that executes after the schema compilation phase of the Executor is complete.
-    abstract PostCompileSchema : SchemaPostCompileMiddleware option
+    abstract PostCompileSchema : SchemaPostCompileMiddleware voption
     /// Defines the sub-middleware that intercepts the operation planning phase of the Executor.
-    abstract PlanOperation : OperationPlanningMiddleware option
+    abstract PlanOperation : OperationPlanningMiddleware voption
     /// Defines the sub-middleware that intercepts the operation execution phase of the Executor.
-    abstract ExecuteOperationAsync : OperationExecutionMiddleware option
+    abstract ExecuteOperationAsync : OperationExecutionMiddleware voption
 
 /// A simple, concrete implementation for the IExecutorMiddleware interface.
-type ExecutorMiddleware(?compile, ?postCompile, ?plan, ?execute) =
+type ExecutorMiddleware([<Struct>] ?compile, [<Struct>] ?postCompile, [<Struct>] ?plan, [<Struct>] ?execute) =
     interface IExecutorMiddleware with
         member _.CompileSchema = compile
         member _.PostCompileSchema = postCompile
@@ -77,7 +77,7 @@ type Executor<'Root>(schema: ISchema<'Root>, middlewares : IExecutorMiddleware s
 
     let middlewaresList = Seq.toList middlewares
 
-    let rec runMiddlewares (phaseSel : IExecutorMiddleware -> ('ctx -> ('ctx -> 'res) -> 'res) option)
+    let rec runMiddlewares (phaseSel : IExecutorMiddleware -> ('ctx -> ('ctx -> 'res) -> 'res) voption)
                            (initialCtx : 'ctx)
                            (onComplete : 'ctx -> 'res)
                            : 'res =
@@ -86,8 +86,8 @@ type Executor<'Root>(schema: ISchema<'Root>, middlewares : IExecutorMiddleware s
             | [] -> onComplete ctx
             | m :: ms ->
                 match (phaseSel m) with
-                | Some f -> f ctx (fun ctx' -> go ctx' ms)
-                | None -> go ctx ms
+                | ValueSome f -> f ctx (fun ctx' -> go ctx' ms)
+                | ValueNone -> go ctx ms
         go initialCtx middlewaresList
 
     do
@@ -124,7 +124,7 @@ type Executor<'Root>(schema: ISchema<'Root>, middlewares : IExecutorMiddleware s
                           FieldExecuteMap = fieldExecuteMap
                           Metadata = executionPlan.Metadata }
                     let executorMiddlewareFunc = fun (executorMiddleware : IExecutorMiddleware) ->
-                            executorMiddleware.ExecuteOperationAsync |> Option.map (fun middleware -> middleware(getInputContext))
+                            executorMiddleware.ExecuteOperationAsync |> ValueOption.map (fun middleware -> middleware(getInputContext))
                     let! res = runMiddlewares executorMiddlewareFunc executionCtx executeOperation |> AsyncVal.toAsync
                     return prepareOutput res
             with
diff --git a/src/FSharp.Data.GraphQL.Server/FSharp.Data.GraphQL.Server.fsproj b/src/FSharp.Data.GraphQL.Server/FSharp.Data.GraphQL.Server.fsproj
index c409a5d0..2be8baa1 100644
--- a/src/FSharp.Data.GraphQL.Server/FSharp.Data.GraphQL.Server.fsproj
+++ b/src/FSharp.Data.GraphQL.Server/FSharp.Data.GraphQL.Server.fsproj
@@ -18,6 +18,7 @@
     <InternalsVisibleTo Include="FSharp.Data.GraphQL.Tests" />
     <InternalsVisibleTo Include="FSharp.Data.GraphQL.Server.AspNetCore" />
     <InternalsVisibleTo Include="FSharp.Data.GraphQL.Server.Middleware" />
+    <InternalsVisibleTo Include="FSharp.Data.GraphQL.Server.Suave" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/FSharp.Data.GraphQL.Server/Schema.fs b/src/FSharp.Data.GraphQL.Server/Schema.fs
index 93503639..8f9c87d1 100644
--- a/src/FSharp.Data.GraphQL.Server/Schema.fs
+++ b/src/FSharp.Data.GraphQL.Server/Schema.fs
@@ -169,12 +169,9 @@ type SchemaConfig =
             Directives = [ IncludeDirective; SkipDirective; DeferDirective; streamDirective; LiveDirective ] }
 
 /// GraphQL server schema. Defines the complete type system to be used by GraphQL queries.
-type Schema<'Root> (query: ObjectDef<'Root>, [<Struct>] ?mutation: ObjectDef<'Root>, [<Struct>] ?subscription: SubscriptionObjectDef<'Root>, ?config: SchemaConfig) =
+type Schema<'Root> (query: ObjectDef<'Root>, [<Struct>] ?mutation: ObjectDef<'Root>, [<Struct>] ?subscription: SubscriptionObjectDef<'Root>, [<Struct>] ?config: SchemaConfig) =
 
-    let schemaConfig =
-        match config with
-        | None -> SchemaConfig.Default
-        | Some c -> c
+    let schemaConfig = defaultValueArg config SchemaConfig.Default
 
     let typeMap : TypeMap =
 
diff --git a/tests/FSharp.Data.GraphQL.Tests/ExecutorMiddlewareTests.fs b/tests/FSharp.Data.GraphQL.Tests/ExecutorMiddlewareTests.fs
index 77aece82..0bd6ea8f 100644
--- a/tests/FSharp.Data.GraphQL.Tests/ExecutorMiddlewareTests.fs
+++ b/tests/FSharp.Data.GraphQL.Tests/ExecutorMiddlewareTests.fs
@@ -99,10 +99,10 @@ let executionMiddleware (inputContext : InputExecutionContextProvider) (ctx : Ex
 
 let middleware =
     { new IExecutorMiddleware with
-        member _.CompileSchema = Some compileMiddleware
-        member _.PostCompileSchema = Some postCompileMiddleware
-        member _.PlanOperation = Some planningMiddleware
-        member _.ExecuteOperationAsync = Some executionMiddleware }
+        member _.CompileSchema = ValueSome compileMiddleware
+        member _.PostCompileSchema = ValueSome postCompileMiddleware
+        member _.PlanOperation = ValueSome planningMiddleware
+        member _.ExecuteOperationAsync = ValueSome executionMiddleware }
 
 let executor = Executor(schema, [ middleware ])