Gql

Micro.Starter.Api/GraphQL/Directives/AuthorizeDirective.cs

@@ -0,0 +1,50 @@
+using GraphQL;
+using GraphQL.Resolvers;
+using GraphQL.Types;
+using GraphQL.Utilities;
+using Micro.Starter.Api.GraphQL.Directives.Exceptions;
+using Microsoft.AspNetCore.Http;
+
+namespace Micro.Starter.Api.GraphQL.Directives
+{
+    public class AuthorizeDirective : DirectiveGraphType
+    {
+        public const string DirectiveName = "authorize";
+        public override bool? Introspectable => true;
+
+        public AuthorizeDirective() : base(
+            DirectiveName,
+            DirectiveLocation.Field,
+            DirectiveLocation.Mutation,
+            DirectiveLocation.Query,
+            DirectiveLocation.FieldDefinition)
+        {
+        }
+    }
+    public class AuthorizeDirectiveVisitor : BaseSchemaNodeVisitor
+    {
+        private readonly IHttpContextAccessor _contextAccessor;
+
+        public AuthorizeDirectiveVisitor(IHttpContextAccessor contextAccessor)
+        {
+            _contextAccessor = contextAccessor;
+        }
+
+        public override void VisitObjectFieldDefinition(FieldType field, IObjectGraphType type, ISchema schema)
+        {
+            var applied = field.FindAppliedDirective(AuthorizeDirective.DirectiveName);
+            if (applied == null)
+            {
+                return;
+            }
+
+            var isAuthenticated = _contextAccessor.HttpContext?.User.Identity?.IsAuthenticated;
+            if (isAuthenticated == true)
+            {
+                return;
+            }
+
+            field.Resolver = new AsyncFieldResolver<object>(async context => { throw new NotAuthorizedException(); });
+        }
+    }
+}

Micro.Starter.Api/GraphQL/Directives/Exceptions/NotAuthorizedException.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Micro.Starter.Api.GraphQL.Directives.Exceptions
+{
+    public class NotAuthorizedException : Exception
+    {
+        public NotAuthorizedException() : base("This operation requires logging in")
+        {
+        }
+    }
+}

Micro.Starter.Api/GraphQL/Extensions/Directives.cs

@@ -0,0 +1,21 @@
+using GraphQL;
+using GraphQL.Builders;
+using GraphQL.Types;
+using Micro.Starter.Api.GraphQL.Directives;
+
+namespace Micro.Starter.Api.GraphQL.Extensions
+{
+    public static class Directives
+    {
+        public static FieldType Authorize(this FieldType type)
+        {
+            return type.ApplyDirective(AuthorizeDirective.DirectiveName);
+        }
+
+        public static FieldBuilder<TSourceType, TReturnType> Authorize<TSourceType, TReturnType>(
+            this FieldBuilder<TSourceType, TReturnType> type)
+        {
+            return type.Directive(AuthorizeDirective.DirectiveName);
+        }
+    }
+}

Micro.Starter.Api/GraphQL/Extensions/Startup.cs

@@ -0,0 +1,56 @@
+using GraphQL;
+using GraphQL.DataLoader;
+using GraphQL.Execution;
+using GraphQL.Server;
+using GraphQL.Server.Ui.GraphiQL;
+using GraphQL.Server.Ui.Playground;
+using GraphQL.SystemTextJson;
+using GraphQL.Types;
+using Micro.GraphQL.Federation;
+using Micro.Starter.Api.GraphQL.Directives;
+using Micro.Starter.Api.GraphQL.Types;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Micro.Starter.Api.GraphQL.Extensions
+{
+    public static class Startup
+    {
+        public static void ConfigureGraphql(this IServiceCollection services)
+        {
+            services.EnableFederation<EntityType>();
+            services.AddSingleton<IDocumentExecuter, DocumentExecuter>();
+            services.AddSingleton<IDocumentWriter, DocumentWriter>();
+            services.AddSingleton<IDataLoaderContextAccessor, DataLoaderContextAccessor>();
+            services.AddSingleton<IDocumentExecutionListener, DataLoaderDocumentListener>();
+            services.AddTransient<ISchema, StarterSchema>();
+            services.AddTransient<Query>();
+            services.AddTransient<WeatherType>();
+            services.AddScoped<AuthorizeDirectiveVisitor>();
+            services
+                .AddGraphQL(options =>
+                {
+                    options.UnhandledExceptionDelegate = ctx =>
+                    {
+                        ctx.ErrorMessage = ctx.OriginalException.Message;
+                    };
+                })
+                .AddDataLoader()
+                .AddSystemTextJson()
+                .AddErrorInfoProvider(opts => opts.ExposeExceptionStackTrace = true);
+        }
+        public static void SetupGraphQl(this IApplicationBuilder app)
+        {
+            app.UseGraphQL<ISchema>();
+            app.UseGraphQLGraphiQL(new GraphiQLOptions
+            {
+                SubscriptionsEndPoint = null,
+                GraphQLEndPoint = "/graphql"
+            }, "/ui/graphql");
+            app.UseGraphQLPlayground(new PlaygroundOptions
+            {
+                GraphQLEndPoint = "/graphql",
+            }, "/ui/playground");
+        }
+    }
+}

Micro.Starter.Api/GraphQL/Query.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Micro.GraphQL.Federation;
+using Micro.Starter.Api.GraphQL.Types;
+using Micro.Starter.Storage;
+
+namespace Micro.Starter.Api.GraphQL
+{
+    public sealed class Query : Query<EntityType>
+    {
+        public Query()
+        {
+            Field<WeatherType, Weather>()
+                .Name("weather")
+                .ResolveAsync(x => Task.FromResult(new Weather
+                {
+                    Id = "id",
+                    Temperature = 23.3
+                }));
+        }
+    }
+}

Micro.Starter.Api/GraphQL/StarterSchema.cs

@@ -0,0 +1,17 @@
+using System;
+using Micro.GraphQL.Federation;
+using Micro.Starter.Api.GraphQL.Directives;
+using Micro.Starter.Api.GraphQL.Types;
+
+namespace Micro.Starter.Api.GraphQL
+{
+    public class StarterSchema : Schema<EntityType>
+    {
+        public StarterSchema(IServiceProvider services, Query query) : base(services)
+        {
+            Query = query;
+            Directives.Register(new AuthorizeDirective());
+            RegisterVisitor(typeof(AuthorizeDirectiveVisitor));
+        }
+    }
+}

Micro.Starter.Api/GraphQL/Types/EntityType.cs

@@ -0,0 +1,10 @@
+namespace Micro.Starter.Api.GraphQL.Types
+{
+    public class EntityType : Micro.GraphQL.Federation.Types.EntityType
+    {
+        public EntityType()
+        {
+            Type<WeatherType>();
+        }
+    }
+}

Micro.Starter.Api/GraphQL/Types/WeatherType.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Micro.GraphQL.Federation;
+using Micro.Starter.Storage;
+
+namespace Micro.Starter.Api.GraphQL.Types
+{
+    public sealed class WeatherType : ObjectGraphType<Weather>
+    {
+        public WeatherType()
+        {
+            Name = "Weather";
+            Field("id", x => x.Id);
+            Field("temperature", x => x.Temperature);
+            ResolveReferenceAsync(ctx => Task.FromResult(new Weather
+            {
+                Id = "id",
+                Temperature = 32.2
+            }));
+        }
+    }
+}

Micro.Starter.Api/Internal/Configs/Services.cs

@@ -0,0 +1,12 @@
+namespace Micro.Starter.Api.Internal.Configs
+{
+    public class Services
+    {
+        public KeyStoreConfig KeyStore { set; get; }
+    }
+
+    public class KeyStoreConfig
+    {
+        public string Url { set; get; }
+    }
+}

Micro.Starter.Api/Configs/SlackLoggingConfig.cs → Micro.Starter.Api/Internal/Configs/SlackLoggingConfig.cs

@@ -1,6 +1,6 @@
 using Microsoft.Extensions.Logging;
 
-namespace Micro.Starter.Api.Configs
+namespace Micro.Starter.Api.Internal.Configs
 {
     public class SlackLoggingConfig
     {

Micro.Starter.Api/HealthCheck/ConnectionToDbCheck.cs → Micro.Starter.Api/Internal/HealthCheck/ConnectionToDbCheck.cs

@@ -1,9 +1,9 @@
 using System.Threading;
 using System.Threading.Tasks;
-using Micro.Starter.Api.Models;
+using Micro.Starter.Storage;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 
-namespace Micro.Starter.Api.HealthCheck
+namespace Micro.Starter.Api.Internal.HealthCheck
 {
     public class ConnectionToDbCheck : IHealthCheck
     {

Micro.Starter.Api/HealthCheck/MemoryCheck.cs → Micro.Starter.Api/Internal/HealthCheck/MemoryCheck.cs

@@ -4,7 +4,7 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
 
-namespace Micro.Starter.Api.HealthCheck
+namespace Micro.Starter.Api.Internal.HealthCheck
 {
     public class MemoryCheck : IHealthCheck
     {

Micro.Starter.Api/StartupExtensions/Configuration.cs → Micro.Starter.Api/Internal/StartupExtensions/Configuration.cs

@@ -1,14 +1,16 @@
-using Micro.Starter.Api.Configs;
+using Micro.Starter.Api.Internal.Configs;
+using Micro.Starter.Storage;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Micro.Starter.Api.StartupExtensions
+namespace Micro.Starter.Api.Internal.StartupExtensions
 {
     public static class Configuration
     {
         public static void AddConfiguration(this IServiceCollection services, IConfiguration configuration)
         {
             services.Configure<DatabaseConfig>(configuration.GetSection("DatabaseConfig"));
+            services.Configure<Services>(configuration.GetSection("Services"));
             services.Configure<SlackLoggingConfig>(configuration.GetSection("Logging").GetSection("Slack"));
         }
     }

Micro.Starter.Api/StartupExtensions/Database.cs → Micro.Starter.Api/Internal/StartupExtensions/Database.cs

@@ -1,12 +1,12 @@
 using System;
 using System.Threading.Tasks;
-using Micro.Starter.Api.Models;
+using Micro.Starter.Storage;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.Extensions.Logging;
 
-namespace Micro.Starter.Api.StartupExtensions
+namespace Micro.Starter.Api.Internal.StartupExtensions
 {
     public static class Database
     {

Micro.Starter.Api/StartupExtensions/DependencyInjection.cs → Micro.Starter.Api/Internal/StartupExtensions/DependencyInjection.cs

@@ -1,14 +1,14 @@
-using Micro.Starter.Api.Models;
-using Micro.Starter.Api.Repository;
-using Micro.Starter.Api.Uuid;
+using Micro.Starter.Common.Uuid;
+using Micro.Starter.Storage;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Micro.Starter.Api.StartupExtensions
+namespace Micro.Starter.Api.Internal.StartupExtensions
 {
     public static class DependencyInjection
     {
         public static void ConfigureRequiredDependencies(this IServiceCollection services)
         {
+            services.AddHttpContextAccessor();
             services.AddDbContext<ApplicationContext>();
             services.AddScoped<IWeatherRepository, WeatherRepository>();
             services.AddSingleton<IUuidService, UuidService>();

Micro.Starter.Api/StartupExtensions/HealthChecks.cs → Micro.Starter.Api/Internal/StartupExtensions/HealthChecks.cs

@@ -1,6 +1,6 @@
 using System.Linq;
 using System.Threading.Tasks;
-using Micro.Starter.Api.HealthCheck;
+using Micro.Starter.Api.Internal.HealthCheck;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Diagnostics.HealthChecks;
 using Microsoft.AspNetCore.Http;
@@ -10,7 +10,7 @@
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 
-namespace Micro.Starter.Api.StartupExtensions
+namespace Micro.Starter.Api.Internal.StartupExtensions
 {
     public static class HealthChecks
     {

Micro.Starter.Api/StartupExtensions/Logger.cs → Micro.Starter.Api/Internal/StartupExtensions/Logger.cs

@@ -1,10 +1,10 @@
 using System;
-using Micro.Starter.Api.Configs;
+using Micro.Starter.Api.Internal.Configs;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Slack;
 
-namespace Micro.Starter.Api.StartupExtensions
+namespace Micro.Starter.Api.Internal.StartupExtensions
 {
     public static class Logger
     {