├── .gitignore
├── GraphQL.Middleware.xproj
├── GraphQL.Middleware.xproj.user
├── GraphQLMiddleware.cs
├── GraphQLOptions.cs
├── GraphQLRequest.cs
├── GraphiQLMiddleware.cs
├── GraphiQLOptions.cs
├── IApplicationBuilderExtensions.cs
├── LICENSE
├── README.md
├── project.json
└── project.lock.json


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | bin


--------------------------------------------------------------------------------
/GraphQL.Middleware.xproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <PropertyGroup>
 4 |     <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0</VisualStudioVersion>
 5 |     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
 6 |   </PropertyGroup>
 7 | 
 8 |   <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
 9 |   <PropertyGroup Label="Globals">
10 |     <ProjectGuid>9f18d386-a242-4696-97f1-20a892540ce4</ProjectGuid>
11 |     <RootNamespace>GraphQL.Middleware</RootNamespace>
12 |     <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
13 |     <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
14 |     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
15 |   </PropertyGroup>
16 | 
17 |   <PropertyGroup>
18 |     <SchemaVersion>2.0</SchemaVersion>
19 |   </PropertyGroup>
20 |   <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
21 | </Project>
22 | 


--------------------------------------------------------------------------------
/GraphQL.Middleware.xproj.user:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
3 |   <PropertyGroup>
4 |     <ActiveDebugProfile>Start</ActiveDebugProfile>
5 |   </PropertyGroup>
6 | </Project>


--------------------------------------------------------------------------------
/GraphQLMiddleware.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Threading.Tasks;
  4 | using GraphQL.Http;
  5 | using GraphQL.Types;
  6 | using Microsoft.AspNetCore.Http;
  7 | using Microsoft.Extensions.Options;
  8 | using Newtonsoft.Json;
  9 | 
 10 | namespace GraphQL.Middleware
 11 | {
 12 |     /// <summary>
 13 |     ///     Provides middleware for hosting GraphQL.
 14 |     /// </summary>
 15 |     public sealed class GraphQLMiddleware
 16 |     {
 17 |         private readonly string graphqlPath;
 18 |         private readonly RequestDelegate next;
 19 |         private readonly ISchema schema;
 20 | 
 21 |         /// <summary>
 22 |         ///     Initializes a new instance of the <see cref="GraphQLMiddleware" /> class.
 23 |         /// </summary>
 24 |         /// <param name="next">
 25 |         ///     The next request delegate.
 26 |         /// </param>
 27 |         /// <param name="options">
 28 |         ///     The GraphQL options.
 29 |         /// </param>
 30 |         /// <exception cref="ArgumentNullException">
 31 |         ///     Throws <see cref="ArgumentNullException" /> if <paramref name="next" /> or <paramref name="options" /> is null.
 32 |         /// </exception>
 33 |         public GraphQLMiddleware(RequestDelegate next , IOptions<GraphQLOptions> options)
 34 |         {
 35 |             if (next == null)
 36 |             {
 37 |                 throw new ArgumentNullException(nameof(next));
 38 |             }
 39 |             if (options == null)
 40 |             {
 41 |                 throw new ArgumentNullException(nameof(options));
 42 |             }
 43 |             if (options.Value?.Schema == null)
 44 |             {
 45 |                 throw new ArgumentException("Schema is null");
 46 |             }
 47 | 
 48 |             this.next = next;
 49 |             var optionsValue = options.Value;
 50 |             graphqlPath = string.IsNullOrEmpty(optionsValue?.GraphQLPath) ? GraphQLOptions.DefaultGraphQLPath : optionsValue.GraphQLPath;
 51 |             schema = optionsValue?.Schema;
 52 |         }
 53 | 
 54 |         /// <summary>
 55 |         ///     Invokes the middleware with the specified context.
 56 |         /// </summary>
 57 |         /// <param name="context">
 58 |         ///     The context.
 59 |         /// </param>
 60 |         /// <returns>
 61 |         ///     A <see cref="Task" /> representing the middleware invocation.
 62 |         /// </returns>
 63 |         /// <exception cref="ArgumentNullException">
 64 |         ///     Throws <see cref="ArgumentNullException" /> if <paramref name="context" />.
 65 |         /// </exception>
 66 |         public async Task Invoke(HttpContext context)
 67 |         {
 68 |             if (context == null)
 69 |             {
 70 |                 throw new ArgumentNullException(nameof(context));
 71 |             }
 72 | 
 73 |             if (ShouldRespondToRequest(context.Request))
 74 |             {
 75 |                 var executionResult = await ExecuteAsync(context.Request).ConfigureAwait(true);
 76 |                 await WriteResponseAsync(context.Response , executionResult).ConfigureAwait(true);
 77 |                 return;
 78 |             }
 79 | 
 80 |             await next(context).ConfigureAwait(true);
 81 |         }
 82 | 
 83 |         private async Task<ExecutionResult> ExecuteAsync(HttpRequest request)
 84 |         {
 85 |             string requestBodyText;
 86 |             using (var streamReader = new StreamReader(request.Body))
 87 |             {
 88 |                 requestBodyText = await streamReader.ReadToEndAsync().ConfigureAwait(true);
 89 |             }
 90 |             var graphqlRequest = JsonConvert.DeserializeObject<GraphQLRequest>(requestBodyText);
 91 |             return await new DocumentExecuter().ExecuteAsync(schema , null , graphqlRequest.Query , graphqlRequest.OperationName , graphqlRequest.Variables.ToInputs()).ConfigureAwait(true);
 92 |         }
 93 | 
 94 |         private bool ShouldRespondToRequest(HttpRequest request)
 95 |         {
 96 |             bool a = string.Equals(request.Method , "POST" , StringComparison.OrdinalIgnoreCase);
 97 |             bool b = request.Path.Equals(graphqlPath);
 98 |             return a && b;
 99 |         }
100 | 
101 |         private static Task WriteResponseAsync(HttpResponse response , ExecutionResult executionResult)
102 |         {
103 |             response.ContentType = "application/json";
104 |             response.StatusCode = (executionResult.Errors?.Count ?? 0) == 0 ? 200 : 400;
105 |             var graphqlResponse = new DocumentWriter().Write(executionResult);
106 |             return response.WriteAsync(graphqlResponse);
107 |         }
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/GraphQLOptions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Threading.Tasks;
 5 | using GraphQL.Types;
 6 | 
 7 | namespace GraphQL.Middleware
 8 | {
 9 |     /// <summary>
10 |     ///     Options for the <see cref="GraphQLMiddleware" />.
11 |     /// </summary>
12 |     public sealed class GraphQLOptions
13 |     {
14 |         /// <summary>
15 |         ///     The default GraphQL path.
16 |         /// </summary>
17 |         public const string DefaultGraphQLPath = "/graphql";
18 | 
19 |         /// <summary>
20 |         ///     Create an instance with the default options settings.
21 |         /// </summary>
22 |         public GraphQLOptions()
23 |         {
24 |             GraphQLPath = DefaultGraphQLPath;
25 |         }
26 | 
27 |         /// <summary>
28 |         ///     Provides the path to GraphQL endpoint.
29 |         /// </summary>
30 |         /// <remarks>
31 |         ///     Include leading forward slash.  Defaults to "/graphql".
32 |         /// </remarks>
33 |         public string GraphQLPath { get; set; }
34 | 
35 |         /// <summary>
36 |         ///     Provides the schema instance.
37 |         /// </summary>
38 |         public ISchema Schema { get; set; }
39 |     }
40 | 
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/GraphQLRequest.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace GraphQL.Middleware
 7 | {
 8 |     internal sealed class GraphQLRequest
 9 |     {
10 |         public string OperationName { get; set; }
11 | 
12 |         public string Query { get; set; }
13 | 
14 |         public string Variables { get; set; }
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/GraphiQLMiddleware.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Reflection;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using Microsoft.AspNetCore.Http;
  7 | using Microsoft.Extensions.Options;
  8 | 
  9 | namespace GraphQL.Middleware
 10 | {
 11 |     /// <summary>
 12 |     ///     Provides middleware to display GraphiQL.
 13 |     /// </summary>
 14 |     public sealed class GraphiQLMiddleware
 15 |     {
 16 |         private static readonly string Template = ReadTemplate();
 17 |         private readonly string graphiqlPath;
 18 |         private readonly string graphqlPath;
 19 |         private readonly RequestDelegate next;
 20 | 
 21 |         /// <summary>
 22 |         ///     Initializes a new instance of the <see cref="GraphiQLMiddleware" /> class.
 23 |         /// </summary>
 24 |         /// <param name="next">
 25 |         ///     The next request delegate.
 26 |         /// </param>
 27 |         /// <param name="options">
 28 |         ///     The GraphiQL options.
 29 |         /// </param>
 30 |         /// <exception cref="ArgumentNullException">
 31 |         ///     Throws <see cref="ArgumentNullException" /> if <paramref name="next" /> or <paramref name="options" /> is null.
 32 |         /// </exception>
 33 |         public GraphiQLMiddleware(RequestDelegate next , IOptions<GraphiQLOptions> options)
 34 |         {
 35 |             if (next == null)
 36 |             {
 37 |                 throw new ArgumentNullException(nameof(next));
 38 |             }
 39 |             if (options == null)
 40 |             {
 41 |                 throw new ArgumentNullException(nameof(options));
 42 |             }
 43 | 
 44 |             this.next = next;
 45 |             var optionsValue = options.Value;
 46 |             graphiqlPath = string.IsNullOrEmpty(optionsValue?.GraphiQLPath) ? GraphiQLOptions.DefaultGraphiQLPath : optionsValue.GraphiQLPath;
 47 |             graphqlPath = string.IsNullOrEmpty(optionsValue?.GraphQLPath) ? GraphiQLOptions.DefaultGraphQLPath : optionsValue.GraphQLPath;
 48 |         }
 49 | 
 50 |         /// <summary>
 51 |         ///     Invokes the middleware with the specified context.
 52 |         /// </summary>
 53 |         /// <param name="context">
 54 |         ///     The context.
 55 |         /// </param>
 56 |         /// <returns>
 57 |         ///     A <see cref="Task" /> representing the middleware invocation.
 58 |         /// </returns>
 59 |         /// <exception cref="ArgumentNullException">
 60 |         ///     Throws <see cref="ArgumentNullException" /> if <paramref name="context" />.
 61 |         /// </exception>
 62 |         public async Task Invoke(HttpContext context)
 63 |         {
 64 |             if (context == null)
 65 |             {
 66 |                 throw new ArgumentNullException(nameof(context));
 67 |             }
 68 | 
 69 |             if (ShouldRespondToRequest(context.Request))
 70 |             {
 71 |                 await WriteResponseAsync(context.Response).ConfigureAwait(true);
 72 |                 return;
 73 |             }
 74 | 
 75 |             await next(context).ConfigureAwait(true);
 76 |         }
 77 | 
 78 |         private static string ReadTemplate()
 79 |         {
 80 |             return @"
 81 | <!--
 82 |  *  Copyright (c) 2015, Facebook, Inc.
 83 |  *  All rights reserved.
 84 |  *
 85 |  *  This source code is licensed under the license found in the
 86 |  *  LICENSE file in the root directory of this source tree.
 87 |  *
 88 | -->
 89 | <!DOCTYPE html>
 90 | <html>
 91 | <head>
 92 |     <style>
 93 |         body {
 94 |             height: 100%;
 95 |             margin: 0;
 96 |             width: 100%;
 97 |             overflow: hidden;
 98 |         }
 99 | 
100 |         #graphiql {
101 |             height: 100vh;
102 |         }
103 |     </style>
104 |     <title>GraphiQL</title>
105 |     <link rel='stylesheet' href='https://cdn.jsdelivr.net/graphiql/0.7.5/graphiql.css' />
106 |     <script src='https://cdn.jsdelivr.net/fetch/latest/fetch.min.js'></script>
107 |     <script src='https://cdn.jsdelivr.net/react/latest/react.min.js'></script>
108 |     <script src='https://cdn.jsdelivr.net/react/latest/react-dom.min.js'></script>
109 |     <script src='https://cdn.jsdelivr.net/graphiql/0.7.5/graphiql.min.js'></script>
110 | </head>
111 | <body>
112 |     <div id='graphiql'>Loading...</div>
113 |     <script>
114 |       /**
115 |        * This GraphiQL example illustrates how to use some of GraphiQL's props
116 |        * in order to enable reading and updating the URL parameters, making
117 |        * link sharing of queries a little bit easier.
118 |        *
119 |        * This is only one example of this kind of feature, GraphiQL exposes
120 |        * various React params to enable interesting integrations.
121 |        */
122 |       // Parse the search string to get url parameters.
123 |       var search = window.location.search;
124 |       var parameters = {};
125 |       search.substr(1).split('&').forEach(function (entry) {
126 |         var eq = entry.indexOf('=');
127 |         if (eq >= 0) {
128 |           parameters[decodeURIComponent(entry.slice(0, eq))] =
129 |             decodeURIComponent(entry.slice(eq + 1));
130 |         }
131 |       });
132 |       // if variables was provided, try to format it.
133 |       if (parameters.variables) {
134 |         try {
135 |           parameters.variables =
136 |             JSON.stringify(JSON.parse(parameters.variables), null, 2);
137 |         } catch (e) {
138 |           // Do nothing, we want to display the invalid JSON as a string, rather
139 |           // than present an error.
140 |         }
141 |       }
142 |       // When the query and variables string is edited, update the URL bar so
143 |       // that it can be easily shared
144 |       function onEditQuery(newQuery) {
145 |         parameters.query = newQuery;
146 |         updateURL();
147 |       }
148 |       function onEditVariables(newVariables) {
149 |         parameters.variables = newVariables;
150 |         updateURL();
151 |       }
152 |       function onEditOperationName(newOperationName) {
153 |         parameters.operationName = newOperationName;
154 |         updateURL();
155 |       }
156 |       function updateURL() {
157 |         var newSearch = '?' + Object.keys(parameters).filter(function (key) {
158 |           return Boolean(parameters[key]);
159 |         }).map(function (key) {
160 |           return encodeURIComponent(key) + '=' +
161 |             encodeURIComponent(parameters[key]);
162 |         }).join('&');
163 |         history.replaceState(null, null, newSearch);
164 |       }
165 |       // Defines a GraphQL fetcher using the fetch API.
166 |       function graphQLFetcher(graphQLParams) {
167 |         return fetch(window.location.origin + '@{GraphQLPath}', {
168 |           method: 'post',
169 |           headers: {
170 |             'Accept': 'application/json',
171 |             'Content-Type': 'application/json',
172 |           },
173 |           body: JSON.stringify(graphQLParams),
174 |           credentials: 'include',
175 |         }).then(function (response) {
176 |           return response.text();
177 |         }).then(function (responseBody) {
178 |           try {
179 |             return JSON.parse(responseBody);
180 |           } catch (error) {
181 |             return responseBody;
182 |           }
183 |         });
184 |       }
185 |       // Render <GraphiQL /> into the body.
186 |       ReactDOM.render(
187 |         React.createElement(GraphiQL, {
188 |           fetcher: graphQLFetcher,
189 |           query: parameters.query,
190 |           variables: parameters.variables,
191 |           operationName: parameters.operationName,
192 |           onEditQuery: onEditQuery,
193 |           onEditVariables: onEditVariables,
194 |           onEditOperationName: onEditOperationName
195 |         }),
196 |         document.getElementById('graphiql')
197 |       );
198 |     </script>
199 | </body>
200 | </html>
201 | ";
202 |             //var assembly = typeof(IApplicationBuilderExtensions).GetTypeInfo().Assembly;
203 |             //var a = assembly.GetManifestResourceNames();
204 |             //using (var stream = assembly.GetManifestResourceStream("index.html"))
205 |             //using (var streamReader = new StreamReader(stream , Encoding.UTF8))
206 |             //{
207 |             //    return streamReader.ReadToEnd();
208 |             //}
209 |         }
210 | 
211 |         private bool ShouldRespondToRequest(HttpRequest request)
212 |         {
213 |             return string.Equals(request.Method , "GET" , StringComparison.OrdinalIgnoreCase) && request.Path.Equals(graphiqlPath);
214 |         }
215 | 
216 |         private Task WriteResponseAsync(HttpResponse response)
217 |         {
218 |             response.ContentType = "text/html";
219 |             response.StatusCode = 200;
220 | 
221 |             // TODO: use RazorPageGenerator when ASP.NET Core 1.1 is out...?
222 |             var builder = new StringBuilder(Template);
223 |             builder.Replace("@{GraphQLPath}" , graphqlPath);
224 | 
225 |             var data = Encoding.UTF8.GetBytes(builder.ToString());
226 |             return response.Body.WriteAsync(data , 0 , data.Length);
227 |         }
228 |     }
229 | }
230 | 


--------------------------------------------------------------------------------
/GraphiQLOptions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace GraphQL.Middleware
 7 | {
 8 |     /// <summary>
 9 |     ///     Options for the <see cref="GraphiQLMiddleware" />.
10 |     /// </summary>
11 |     public sealed class GraphiQLOptions
12 |     {
13 |         public const string DefaultGraphiQLPath = "/graphiql";
14 |         public const string DefaultGraphQLPath = "/graphql";
15 | 
16 |         /// <summary>
17 |         ///     Create an instance with the default options settings.
18 |         /// </summary>
19 |         public GraphiQLOptions()
20 |         {
21 |             GraphiQLPath = DefaultGraphiQLPath;
22 |             GraphQLPath = DefaultGraphQLPath;
23 |         }
24 | 
25 |         /// <summary>
26 |         ///     Provides the path to GraphiQL.
27 |         /// </summary>
28 |         /// <remarks>
29 |         ///     Include leading forward slash.  Defaults to "/graphiql".
30 |         /// </remarks>
31 |         public string GraphiQLPath { get; set; }
32 | 
33 |         /// <summary>
34 |         ///     Provides the path to GraphQL endpoint.
35 |         /// </summary>
36 |         /// <remarks>
37 |         ///     Include leading forward slash.  Defaults to "/graphql".
38 |         /// </remarks>
39 |         public string GraphQLPath { get; set; }
40 |     }
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/IApplicationBuilderExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Threading.Tasks;
 5 | using Microsoft.AspNetCore.Builder;
 6 | //using Microsoft.AspNetCore.Builder;
 7 | using Microsoft.Extensions.Options;
 8 | 
 9 | namespace GraphQL.Middleware
10 | {
11 |     /// <summary>
12 |     ///     Extension methods for using GraphiQL with <see cref="IApplicationBuilder" />.
13 |     /// </summary>
14 |     public static class IApplicationBuilderExtensions
15 |     {
16 |         /// <summary>
17 |         ///     Uses GraphiQL with the specified options.
18 |         /// </summary>
19 |         /// <param name="app">
20 |         ///     The application builder.
21 |         /// </param>
22 |         /// <param name="options">
23 |         ///     The options for the GraphiQL middleware.
24 |         /// </param>
25 |         /// <returns>
26 |         ///     The modified application builder.
27 |         /// </returns>
28 |         /// <exception cref="ArgumentNullException">
29 |         ///     Thrown if <paramref name="app" /> or <paramref name="options" /> is null.
30 |         /// </exception>
31 |         public static IApplicationBuilder UseGraphQL(this IApplicationBuilder app , GraphQLOptions options)
32 |         {
33 |             if (app == null)
34 |             {
35 |                 throw new ArgumentNullException(nameof(app));
36 |             }
37 |             if (options == null)
38 |             {
39 |                 throw new ArgumentNullException(nameof(options));
40 |             }
41 |             return app.UseMiddleware<GraphQLMiddleware>(Options.Create(options));
42 |         }
43 | 
44 |         /// <summary>
45 |         ///     Uses GraphiQL with default options.
46 |         /// </summary>
47 |         /// <param name="app">
48 |         ///     The application builder.
49 |         /// </param>
50 |         /// <returns>
51 |         ///     The modified application builder.
52 |         /// </returns>
53 |         /// <exception cref="ArgumentNullException">
54 |         ///     Thrown if <paramref name="app" /> is null.
55 |         /// </exception>
56 |         public static IApplicationBuilder UseGraphiQL(this IApplicationBuilder app)
57 |         {
58 |             if (app == null)
59 |             {
60 |                 throw new ArgumentNullException(nameof(app));
61 |             }
62 |             return app.UseMiddleware<GraphiQLMiddleware>();
63 |         }
64 | 
65 |         /// <summary>
66 |         ///     Uses GraphiQL with the specified options.
67 |         /// </summary>
68 |         /// <param name="app">
69 |         ///     The application builder.
70 |         /// </param>
71 |         /// <param name="options">
72 |         ///     The options for the GraphiQL middleware.
73 |         /// </param>
74 |         /// <returns>
75 |         ///     The modified application builder.
76 |         /// </returns>
77 |         /// <exception cref="ArgumentNullException">
78 |         ///     Thrown if <paramref name="app" /> or <paramref name="options" /> is null.
79 |         /// </exception>
80 |         public static IApplicationBuilder UseGraphiQL(this IApplicationBuilder app , GraphiQLOptions options)
81 |         {
82 |             if (app == null)
83 |             {
84 |                 throw new ArgumentNullException(nameof(app));
85 |             }
86 |             if (options == null)
87 |             {
88 |                 throw new ArgumentNullException(nameof(options));
89 |             }
90 |             return app.UseMiddleware<GraphiQLMiddleware>(Options.Create(options));
91 |         }
92 |     }
93 | }
94 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Wesam
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ASP.Net-Core-GraphQL-Middleware
 2 | ASP.Net Core GraphQL Middleware
 3 | 
 4 | usage:
 5 | in your Startup.cs in the Configure() Method
 6 | 
 7 | ```cs
 8 | app.UseGraphQL(new GraphQLOptions
 9 | {
10 |     GraphQLPath = "/graphql" ,
11 |     Schema = new Schema { Query = new StarWarsQuery() }
12 | });
13 | 
14 | app.UseGraphiQL(new GraphiQLOptions()
15 | {
16 |     GraphiQLPath = "/graphiql"
17 | });
18 | 
19 | ```


--------------------------------------------------------------------------------
/project.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "1.0.0-*",
 3 | 
 4 |   "dependencies": {
 5 |     "Microsoft.AspNetCore.Http.Abstractions": "1.1.0-alpha1-22011",
 6 |     "Microsoft.Extensions.Options": "1.1.0-alpha1-22011",
 7 |     "NETStandard.Library": "1.6.0",
 8 |     "Newtonsoft.Json": "9.0.1",
 9 |     "GraphQL": "0.12.1-alpha-545"
10 |   },
11 | 
12 |   "frameworks": {
13 |     "netstandard1.6": {
14 |       "imports": "dnxcore50"
15 |     }
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------