cache auth tickets / avoid hammering GitHub auth API

Author: retailcoder

rubberduckvba.Server/Api/Features/FeaturesController.cs

@@ -168,8 +168,8 @@ public async Task<ActionResult<FeatureEditViewModel>> Create([FromBody] FeatureE
             return BadRequest("Model is invalid for this endpoint.");
         }
 
-        var existing = await db.GetFeatureId(model.RepositoryId, model.Name);
-        if (existing != null)
+        var existingId = await db.GetFeatureId(model.RepositoryId, model.Name);
+        if (existingId != null)
         {
             return BadRequest($"Model [Name] must be unique; feature '{model.Name}' already exists.");
         }
@@ -191,8 +191,8 @@ public async Task<ActionResult<FeatureEditViewModel>> Update([FromBody] FeatureE
             return BadRequest("Model is invalid for this endpoint.");
         }
 
-        var existing = await db.ResolveFeature(model.RepositoryId, model.Name);
-        if (existing is null)
+        var existingId = await db.GetFeatureId(model.RepositoryId, model.Name);
+        if (existingId is null)
         {
             return BadRequest("Model is invalid for this endpoint.");
         }
@@ -205,7 +205,22 @@ public async Task<ActionResult<FeatureEditViewModel>> Update([FromBody] FeatureE
         return new FeatureEditViewModel(result, features, RepositoryOptions);
     }
 
+    [HttpPost("features/delete")]
+    [Authorize("github")]
+    public async Task Delete([FromBody] IFeature model)
+    {
+        if (model.Id == default)
+        {
+            throw new ArgumentException("Model is invalid for this endpoint.");
+        }
+        var existingId = await db.GetFeatureId(RepositoryId.Rubberduck, model.Name);
+        if (existingId is null)
+        {
+            throw new ArgumentException("Model is invalid for this endpoint.");
+        }
 
+        await db.DeleteFeature(existingId.Value);
+    }
 
     [HttpPost("markdown/format")]
     public MarkdownContentViewModel FormatMarkdown([FromBody] MarkdownContentViewModel model)

rubberduckvba.Server/Data/Repository.cs

@@ -18,6 +18,7 @@ public interface IRepository<TEntity> where TEntity : Entity
     IEnumerable<TEntity> Insert(IEnumerable<TEntity> entities);
     void Update(TEntity entity);
     void Update(IEnumerable<TEntity> entities);
+    void Delete(int id);
 }
 
 public abstract class QueryableRepository<T> where T : class
@@ -88,6 +89,18 @@ public virtual bool TryGetId(string name, out int id)
 
     public virtual int GetId(string name) => Get(db => db.QuerySingle<int>($"SELECT [Id] FROM [dbo].[{TableName}] WHERE [Name]=@name", new { name }));
     public virtual TEntity GetById(int id) => Get(db => db.QuerySingle<TEntity>(SelectSql + " WHERE a.[Id]=@id", new { id }));
+
+    public virtual void Delete(int id)
+    {
+        using var db = new SqlConnection(ConnectionString);
+        db.Open();
+
+        using var transaction = db.BeginTransaction();
+        db.Execute($"DELETE FROM [dbo].[{TableName}] WHERE [Id]=@id", new { id }, transaction);
+
+        transaction.Commit();
+    }
+
     public virtual TEntity Insert(TEntity entity) => Insert([entity]).Single();
     public virtual IEnumerable<TEntity> Insert(IEnumerable<TEntity> entities)
     {

rubberduckvba.Server/GitHubAuthenticationHandler.cs

@@ -1,5 +1,6 @@
 
 using Microsoft.AspNetCore.Authentication;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using rubberduckvba.Server.Services;
 using System.Security.Claims;
@@ -10,12 +11,19 @@ namespace rubberduckvba.Server;
 public class GitHubAuthenticationHandler : AuthenticationHandler<AuthenticationSchemeOptions>
 {
     private readonly IGitHubClientService _github;
+    private readonly IMemoryCache _cache;
 
-    public GitHubAuthenticationHandler(IGitHubClientService github,
+    private static readonly MemoryCacheEntryOptions _options = new MemoryCacheEntryOptions
+    {
+        SlidingExpiration = TimeSpan.FromMinutes(60),
+    };
+
+    public GitHubAuthenticationHandler(IGitHubClientService github, IMemoryCache cache,
         IOptionsMonitor<AuthenticationSchemeOptions> options, ILoggerFactory logger, UrlEncoder encoder)
         : base(options, logger, encoder)
     {
         _github = github;
+        _cache = cache;
     }
 
     protected async override Task<AuthenticateResult> HandleAuthenticateAsync()
@@ -28,12 +36,27 @@ protected async override Task<AuthenticateResult> HandleAuthenticateAsync()
                 return AuthenticateResult.Fail("Access token was not provided");
             }
 
+            if (_cache.TryGetValue(token, out var cached) && cached is AuthenticationTicket cachedTicket)
+            {
+                var cachedPrincipal = cachedTicket.Principal;
+
+                Context.User = cachedPrincipal;
+                Thread.CurrentPrincipal = cachedPrincipal;
+
+                Logger.LogInformation($"Successfully retrieved authentication ticket from cached token for {cachedPrincipal.Identity!.Name}; token will not be revalidated.");
+                return AuthenticateResult.Success(cachedTicket);
+            }
+
             var principal = await _github.ValidateTokenAsync(token);
             if (principal is ClaimsPrincipal)
             {
                 Context.User = principal;
                 Thread.CurrentPrincipal = principal;
-                return AuthenticateResult.Success(new AuthenticationTicket(principal, "github"));
+
+                var ticket = new AuthenticationTicket(principal, "github");
+                _cache.Set(token, ticket, _options);
+
+                return AuthenticateResult.Success(ticket);
             }
 
             return AuthenticateResult.Fail("An invalid access token was provided");

rubberduckvba.Server/Program.cs

@@ -3,6 +3,7 @@
 using Hangfire.Dashboard;
 using Hangfire.SqlServer;
 using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
 using NLog.Config;
 using NLog.Extensions.Logging;
@@ -226,6 +227,7 @@ private static void ConfigureServices(IServiceCollection services)
         services.AddSingleton<CacheService>();
 
         services.AddSession(ConfigureSession);
+        services.AddSingleton<IMemoryCache>(provider => new MemoryCache(new MemoryCacheOptions(), provider.GetRequiredService<ILoggerFactory>()));
     }
 
     private static void ConfigureLogging(IServiceCollection services)

rubberduckvba.Server/Services/RubberduckDbService.cs

@@ -69,6 +69,7 @@ public interface IRubberduckDbService
     Task<FeatureGraph> ResolveFeature(RepositoryId repositoryId, string name);
     Task<int?> GetFeatureId(RepositoryId repositoryId, string name);
     Task<Feature> SaveFeature(Feature feature);
+    Task DeleteFeature(int id);
 }
 
 public class RubberduckDbService : IRubberduckDbService
@@ -238,6 +239,11 @@ public async Task<FeatureGraph> ResolveFeature(RepositoryId repositoryId, string
         //        return graph;
     }
 
+    public async Task DeleteFeature(int id)
+    {
+        _featureServices.DeleteFeature(id);
+    }
+
     public async Task<Feature> SaveFeature(Feature feature)
     {
         if (feature.Id == default)

rubberduckvba.Server/Services/rubberduckdb/FeatureServices.cs

@@ -94,4 +94,6 @@ feature with
     public void Insert(IEnumerable<Inspection> inspections) => inspectionRepository.Insert(inspections.Select(inspection => inspection.ToEntity()));
     public void Insert(IEnumerable<QuickFix> quickFixes) => quickfixRepository.Insert(quickFixes.Select(quickfix => quickfix.ToEntity()));
     public void Insert(IEnumerable<Annotation> annotations) => annotationRepository.Insert(annotations.Select(annotation => annotation.ToEntity()));
+
+    public void DeleteFeature(int id) => featureRepository.Delete(id);
 }