Added caching to GraphQL connections.

Author: grokys

src/GitHub.Api/GitHub.Api.csproj

@@ -17,6 +17,7 @@
   <ItemGroup>
     <Reference Include="System.ComponentModel.Composition" />
     <Reference Include="System.Net.Http" />
+    <Reference Include="System.Runtime.Caching" />
   </ItemGroup>
 
   <ItemGroup>
@@ -30,6 +31,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="FileCache.Signed" Version="2.2.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.6.1" />
     <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
   </ItemGroup>

src/GitHub.Api/GraphQLClient.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Runtime.Caching;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.Threading;
+using Octokit.GraphQL;
+using Octokit.GraphQL.Core;
+
+namespace GitHub.Api
+{
+    public class GraphQLClient : IGraphQLClient
+    {
+        public static readonly TimeSpan DefaultCacheDuration = TimeSpan.FromHours(8);
+        readonly IConnection connection;
+        readonly ObjectCache cache;
+
+        public GraphQLClient(
+            IConnection connection,
+            ObjectCache cache)
+        {
+            this.connection = connection;
+            this.cache = cache;
+        }
+
+        public Task<T> Run<T>(
+            IQueryableValue<T> query,
+            Dictionary<string, object> variables = null,
+            bool refresh = false,
+            TimeSpan? cacheDuration = null,
+            CancellationToken cancellationToken = default)
+        {
+            return Run(query.Compile(), variables, refresh, cacheDuration, cancellationToken);
+        }
+
+        public Task<IEnumerable<T>> Run<T>(
+            IQueryableList<T> query,
+            Dictionary<string, object> variables = null,
+            bool refresh = false,
+            TimeSpan? cacheDuration = null,
+            CancellationToken cancellationToken = default)
+        {
+            return Run(query.Compile(), variables, refresh, cacheDuration, cancellationToken);
+        }
+
+        public async Task<T> Run<T>(
+            ICompiledQuery<T> query,
+            Dictionary<string, object> variables = null,
+            bool refresh = false,
+            TimeSpan? cacheDuration = null,
+            CancellationToken cancellationToken = default)
+        {
+            if (!query.IsMutation)
+            {
+                var wrapper = new CachingWrapper(this, cacheDuration ?? DefaultCacheDuration, refresh);
+                return await wrapper.Run(query, variables, cancellationToken);
+            }
+            else
+            {
+                return await connection.Run(query, variables, cancellationToken);
+            }
+        }
+
+        static string GetHash(string input)
+        {
+            var sb = new StringBuilder();
+
+            using (var hash = SHA256.Create())
+            {
+                var result = hash.ComputeHash(Encoding.UTF8.GetBytes(input));
+
+                foreach (var b in result)
+                {
+                    sb.Append(b.ToString("x2", CultureInfo.InvariantCulture));
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        class CachingWrapper : IConnection
+        {
+            readonly GraphQLClient owner;
+            readonly TimeSpan cacheDuration;
+            readonly bool refresh;
+
+            public CachingWrapper(
+                GraphQLClient owner,
+                TimeSpan cacheDuration,
+                bool refresh)
+            {
+                this.owner = owner;
+                this.cacheDuration = cacheDuration;
+                this.refresh = refresh;
+            }
+
+            public Uri Uri => owner.connection.Uri;
+
+            public async Task<string> Run(string query, CancellationToken cancellationToken = default)
+            {
+                // Switch to background thread because ObjectCache does not provide an async API.
+                await TaskScheduler.Default;
+
+                var hash = GetHash(query);
+
+                if (refresh)
+                {
+                    owner.cache.Remove(hash, Uri.Host);
+                }
+
+                var data = (string)owner.cache.Get(hash, Uri.Host);
+
+                if (data != null)
+                {
+                    return data;
+                }
+
+                var result = await owner.connection.Run(query, cancellationToken);
+                owner.cache.Add(hash, result, DateTimeOffset.Now + cacheDuration, Uri.Host);
+                return result;
+            }
+        }
+    }
+}

src/GitHub.Api/GraphQLClientFactory.cs

@@ -1,6 +1,9 @@
 using System;
 using System.ComponentModel.Composition;
+using System.IO;
+using System.Runtime.Caching;
 using System.Threading.Tasks;
+using GitHub.Info;
 using GitHub.Models;
 using GitHub.Primitives;
 using Octokit.GraphQL;
@@ -17,6 +20,7 @@ public class GraphQLClientFactory : IGraphQLClientFactory
     {
         readonly IKeychain keychain;
         readonly IProgram program;
+        readonly FileCache cache;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="GraphQLClientFactory"/> class.
@@ -28,14 +32,21 @@ public GraphQLClientFactory(IKeychain keychain, IProgram program)
         {
             this.keychain = keychain;
             this.program = program;
+
+            var cachePath = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+                ApplicationInfo.ApplicationName,
+                "GraphQLCache");
+            cache = new FileCache(cachePath);
         }
 
         /// <inheirtdoc/>
-        public Task<Octokit.GraphQL.IConnection> CreateConnection(HostAddress address)
+        public Task<IGraphQLClient> CreateConnection(HostAddress address)
         {
             var credentials = new GraphQLKeychainCredentialStore(keychain, address);
             var header = new ProductHeaderValue(program.ProductHeader.Name, program.ProductHeader.Version);
-            return Task.FromResult<Octokit.GraphQL.IConnection>(new Connection(header, address.GraphQLUri, credentials));
+            var connection = new Connection(header, address.GraphQLUri, credentials);
+            return Task.FromResult<IGraphQLClient>(new GraphQLClient(connection, cache));
         }
     }
 }

src/GitHub.Api/IGraphQLClient.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Octokit.GraphQL;
+using Octokit.GraphQL.Core;
+
+namespace GitHub.Api
+{
+    public interface IGraphQLClient
+    {
+        Task<T> Run<T>(
+            IQueryableValue<T> query,
+            Dictionary<string, object> variables = null,
+            bool refresh = false,
+            TimeSpan? cacheDuration = null,
+            CancellationToken cancellationToken = default);
+
+        Task<IEnumerable<T>> Run<T>(
+            IQueryableList<T> query,
+            Dictionary<string, object> variables = null,
+            bool refresh = false,
+            TimeSpan? cacheDuration = null,
+            CancellationToken cancellationToken = default);
+
+        Task<T> Run<T>(
+            ICompiledQuery<T> query,
+            Dictionary<string, object> variables = null,
+            bool refresh = false,
+            TimeSpan? cacheDuration = null,
+            CancellationToken cancellationToken = default);
+    }
+}

src/GitHub.Api/IGraphQLClientFactory.cs

@@ -4,16 +4,15 @@
 namespace GitHub.Api
 {
     /// <summary>
-    /// Creates GraphQL <see cref="Octokit.GraphQL.IConnection"/>s for querying the
-    /// GitHub GraphQL API.
+    /// Creates <see cref="IGraphQLClient"/>s for querying the GitHub GraphQL API.
     /// </summary>
     public interface IGraphQLClientFactory
     {
         /// <summary>
-        /// Creates a new <see cref="Octokit.GraphQL.IConnection"/>.
+        /// Creates a new <see cref="IGraphQLClient"/>.
         /// </summary>
         /// <param name="address">The address of the server.</param>
-        /// <returns>A task returning the created connection.</returns>
-        Task<Octokit.GraphQL.IConnection> CreateConnection(HostAddress address);
+        /// <returns>A task returning the created client.</returns>
+        Task<IGraphQLClient> CreateConnection(HostAddress address);
     }
 }