In-Memory Cache (#1881)

## Why make this change?

- Second set of work attributed to #1618 #1617 

## What is this change?
- Implements the design in #1801. The one behavior which isn't in this
PR is caching GraphQL "list" queries. That will come in a separate
commit once i resolve the errors that arise with generics and the
DataReaderHandler delegates.
- Creates a `DabCacheService` which is used in database queries
(REST/GraphQL) such that requests and responses are cached in memory.
- This PR is not dependent on #1865. However, once that PR and this PR
are merged, a third follow-up PR will make a small adjustment in
`SqlQueryEngine.ExecuteAsync(...)` such that the `cacheEntryTtl` and
`cacheEnabled` values are resolved from runtime config and used
determine whether to use the cache and how to use the cache.

## How was this tested?

- [x] Integration Tests -> integration tests included which mock the
QueryExecutor and test how the DabCacheService handles request metadata
and caching method execution. The integration tests aim to test the
**behavior** of the DabCacheService and intentionally do not make
private methods public or break out key generation and entry size
calculation into separate classes. Additionally, the integration tests
are not meant to test the functionality of FusionCache. That library has
its own tests which validate functionality.

## Sample Request(s)

Until all related PRs are merged, this feature is gated by a feature
flag. To add the feature flag, add the following snippet to the
`AppConfig.json`:
```json
// Define feature flags in config file
    "FeatureManagement": {
        "CachingPreview": true, // Turn-On feature
    }
``` 

Point requests will be cached with a default 10 second ttl. You can try
out whether response times are quicker for your use case.

Author: seantleonard

src/Config/FeatureFlagConstants.cs

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Config;
+
+public static class FeatureFlagConstants
+{
+    public const string INMEMORYCACHE = "InMemoryCachingPreview";
+}

src/Config/ObjectModel/Entity.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
 
 namespace Azure.DataApiBuilder.Config.ObjectModel;
@@ -56,6 +57,7 @@ public Entity(
     /// </summary>
     /// <returns>Whether caching is enabled for the entity.</returns>
     [JsonIgnore]
+    [MemberNotNullWhen(true, nameof(Cache))]
     public bool IsCachingEnabled =>
         Cache is not null &&
         Cache.Enabled is not null &&

src/Config/ObjectModel/EntityCacheOptions.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
 
 namespace Azure.DataApiBuilder.Config.ObjectModel;
@@ -56,5 +57,6 @@ public EntityCacheOptions(bool? Enabled = null, int? TtlSeconds = null)
     /// property/value specified would be interpreted by DAB as "user explicitly set ttl."
     /// </summary>
     [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+    [MemberNotNullWhen(true, nameof(TtlSeconds))]
     public bool UserProvidedTtlOptions { get; init; } = false;
 }

src/Config/ObjectModel/RuntimeConfig.cs

@@ -329,6 +329,66 @@ public bool IsDevelopmentMode() =>
         Runtime is not null && Runtime.Host is not null
         && Runtime.Host.Mode is HostMode.Development;
 
+    /// <summary>
+    /// Returns the ttl-seconds value for a given entity.
+    /// If the property is not set, returns the global default value set in the runtime config.
+    /// If the global default value is not set, the default value is used (5 seconds).
+    /// </summary>
+    /// <param name="entityName">Name of the entity to check cache configuration.</param>
+    /// <returns>Number of seconds (ttl) that a cache entry should be valid before cache eviction.</returns>
+    /// <exception cref="DataApiBuilderException">Raised when an invalid entity name is provided or if the entity has caching disabled.</exception>
+    public int GetEntityCacheEntryTtl(string entityName)
+    {
+        if (!Entities.TryGetValue(entityName, out Entity? entityConfig))
+        {
+            throw new DataApiBuilderException(
+                message: $"{entityName} is not a valid entity.",
+                statusCode: HttpStatusCode.BadRequest,
+                subStatusCode: DataApiBuilderException.SubStatusCodes.EntityNotFound);
+        }
+
+        if (!entityConfig.IsCachingEnabled)
+        {
+            throw new DataApiBuilderException(
+                message: $"{entityName} does not have caching enabled.",
+                statusCode: HttpStatusCode.BadRequest,
+                subStatusCode: DataApiBuilderException.SubStatusCodes.NotSupported);
+        }
+
+        if (entityConfig.Cache.UserProvidedTtlOptions)
+        {
+            return entityConfig.Cache.TtlSeconds.Value;
+        }
+        else
+        {
+            return GlobalCacheEntryTtl();
+        }
+    }
+
+    /// <summary>
+    /// Whether the caching service should be used for a given operation. This is determined by
+    /// - whether caching is enabled globally
+    /// - whether the datasource is SQL and session context is disabled.
+    /// </summary>
+    /// <returns>Whether cache operations should proceed.</returns>
+    public bool CanUseCache()
+    {
+        bool setSessionContextEnabled = DataSource.GetTypedOptions<MsSqlOptions>()?.SetSessionContext ?? true;
+        return IsCachingEnabled && SqlDataSourceUsed && !setSessionContextEnabled;
+    }
+
+    /// <summary>
+    /// Returns the ttl-seconds value for the global cache entry.
+    /// If no value is explicitly set, returns the global default value.
+    /// </summary>
+    /// <returns>Number of seconds a cache entry should be valid before cache eviction.</returns>
+    public int GlobalCacheEntryTtl()
+    {
+        return Runtime is not null && Runtime.IsCachingEnabled && Runtime.Cache.UserProvidedTtlOptions
+            ? Runtime.Cache.TtlSeconds.Value
+            : EntityCacheOptions.DEFAULT_TTL_SECONDS;
+    }
+
     private void CheckDataSourceNamePresent(string dataSourceName)
     {
         if (!_dataSourceNameToDataSource.ContainsKey(dataSourceName))

src/Config/ObjectModel/RuntimeOptions.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json.Serialization;
 
 namespace Azure.DataApiBuilder.Config.ObjectModel;
@@ -37,6 +38,7 @@ public RuntimeOptions(
     /// </summary>
     /// <returns>Whether caching is enabled globally.</returns>
     [JsonIgnore]
+    [MemberNotNullWhen(true, nameof(Cache))]
     public bool IsCachingEnabled =>
             Cache is not null &&
             Cache.Enabled is not null &&

src/Core/Azure.DataApiBuilder.Core.csproj

@@ -15,7 +15,7 @@
     <PackageReference Include="HotChocolate.AspNetCore.Authorization" />
     <PackageReference Include="HotChocolate.Types.NodaTime" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" />
-    <PackageReference Include="NJsonSchema"/>
+    <PackageReference Include="NJsonSchema" />
     <PackageReference Include="Microsoft.Azure.Cosmos" />
     <PackageReference Include="Microsoft.Data.SqlClient" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" />
@@ -34,6 +34,7 @@
     <PackageReference Include="Polly" />
     <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" />
     <PackageReference Include="System.IO.Abstractions" />
+    <PackageReference Include="ZiggyCreatures.FusionCache" />
   </ItemGroup>
 
   <PropertyGroup Condition="'$(TF_BUILD)' == 'true'">

src/Core/Models/DatabaseQueryMetadata.cs

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace Azure.DataApiBuilder.Core.Models;
+
+/// <summary>
+/// Represents the database query built from a query structure.
+/// Contains all query metadata need to create a cache key.
+/// </summary>
+public class DatabaseQueryMetadata
+{
+    public string QueryText { get; }
+    public string DataSource { get; }
+    public Dictionary<string, DbConnectionParam> QueryParameters { get; }
+
+    /// <summary>
+    /// Creates a "Data Transfer Object" (DTO) used for provided query metadata to dependent services.
+    /// </summary>
+    /// <param name="queryText">Raw query text built from a query structure object.</param>
+    /// <param name="dataSource">Name of the data source where the query will execute.</param>
+    /// <param name="queryParameters">Dictonary of query parameter names and values.</param>
+    public DatabaseQueryMetadata(string queryText, string dataSource, Dictionary<string, DbConnectionParam> queryParameters)
+    {
+        QueryText = queryText;
+        DataSource = dataSource;
+        QueryParameters = queryParameters;
+    }
+}

src/Core/Resolvers/Factories/QueryEngineFactory.cs

@@ -6,6 +6,7 @@
 using Azure.DataApiBuilder.Config.ObjectModel;
 using Azure.DataApiBuilder.Core.Configurations;
 using Azure.DataApiBuilder.Core.Models;
+using Azure.DataApiBuilder.Core.Services.Cache;
 using Azure.DataApiBuilder.Core.Services.MetadataProviders;
 using Azure.DataApiBuilder.Service.Exceptions;
 using Microsoft.AspNetCore.Http;
@@ -29,7 +30,8 @@ public QueryEngineFactory(RuntimeConfigProvider runtimeConfigProvider,
             IHttpContextAccessor contextAccessor,
             IAuthorizationResolver authorizationResolver,
             GQLFilterParser gQLFilterParser,
-            ILogger<IQueryEngine> logger)
+            ILogger<IQueryEngine> logger,
+            DabCacheService cache)
         {
             _queryEngines = new Dictionary<DatabaseType, IQueryEngine>();
 
@@ -38,7 +40,7 @@ public QueryEngineFactory(RuntimeConfigProvider runtimeConfigProvider,
             if (config.SqlDataSourceUsed)
             {
                 IQueryEngine queryEngine = new SqlQueryEngine(
-                    queryManagerFactory, metadataProviderFactory, contextAccessor, authorizationResolver, gQLFilterParser, logger, runtimeConfigProvider);
+                    queryManagerFactory, metadataProviderFactory, contextAccessor, authorizationResolver, gQLFilterParser, logger, runtimeConfigProvider, cache);
                 _queryEngines.Add(DatabaseType.MSSQL, queryEngine);
                 _queryEngines.Add(DatabaseType.MySQL, queryEngine);
                 _queryEngines.Add(DatabaseType.PostgreSQL, queryEngine);

src/Core/Resolvers/SqlQueryEngine.cs

@@ -9,6 +9,7 @@
 using Azure.DataApiBuilder.Core.Models;
 using Azure.DataApiBuilder.Core.Resolvers.Factories;
 using Azure.DataApiBuilder.Core.Services;
+using Azure.DataApiBuilder.Core.Services.Cache;
 using Azure.DataApiBuilder.Core.Services.MetadataProviders;
 using HotChocolate.Resolvers;
 using Microsoft.AspNetCore.Http;
@@ -30,6 +31,7 @@ public class SqlQueryEngine : IQueryEngine
         private readonly ILogger<IQueryEngine> _logger;
         private readonly RuntimeConfigProvider _runtimeConfigProvider;
         private readonly GQLFilterParser _gQLFilterParser;
+        private readonly DabCacheService _cache;
 
         // <summary>
         // Constructor.
@@ -41,7 +43,8 @@ public SqlQueryEngine(
             IAuthorizationResolver authorizationResolver,
             GQLFilterParser gQLFilterParser,
             ILogger<IQueryEngine> logger,
-            RuntimeConfigProvider runtimeConfigProvider)
+            RuntimeConfigProvider runtimeConfigProvider,
+            DabCacheService cache)
         {
             _queryFactory = queryFactory;
             _sqlMetadataProviderFactory = sqlMetadataProviderFactory;
@@ -50,6 +53,7 @@ public SqlQueryEngine(
             _gQLFilterParser = gQLFilterParser;
             _logger = logger;
             _runtimeConfigProvider = runtimeConfigProvider;
+            _cache = cache;
         }
 
         /// <summary>
@@ -199,21 +203,36 @@ public async Task<IActionResult> ExecuteAsync(StoredProcedureRequestContext cont
         // </summary>
         private async Task<JsonDocument?> ExecuteAsync(SqlQueryStructure structure, string dataSourceName)
         {
-            DatabaseType databaseType = _runtimeConfigProvider.GetConfig().GetDataSourceFromDataSourceName(dataSourceName).DatabaseType;
+            RuntimeConfig runtimeConfig = _runtimeConfigProvider.GetConfig();
+            DatabaseType databaseType = runtimeConfig.GetDataSourceFromDataSourceName(dataSourceName).DatabaseType;
             IQueryBuilder queryBuilder = _queryFactory.GetQueryBuilder(databaseType);
             IQueryExecutor queryExecutor = _queryFactory.GetQueryExecutor(databaseType);
 
             // Open connection and execute query using _queryExecutor
             string queryString = queryBuilder.Build(structure);
-            JsonDocument? jsonDocument =
-                await queryExecutor.ExecuteQueryAsync(
-                    sqltext: queryString,
-                    parameters: structure.Parameters,
-                    dataReaderHandler: queryExecutor.GetJsonResultAsync<JsonDocument>,
-                    httpContext: _httpContextAccessor.HttpContext!,
-                    args: null,
-                    dataSourceName: dataSourceName);
-            return jsonDocument;
+
+            if (runtimeConfig.CanUseCache())
+            {
+                bool dbPolicyConfigured = !string.IsNullOrEmpty(structure.DbPolicyPredicatesForOperations[EntityActionOperation.Read]);
+
+                if (dbPolicyConfigured)
+                {
+                    DatabaseQueryMetadata queryMetadata = new(queryText: queryString, dataSource: dataSourceName, queryParameters: structure.Parameters);
+                    JsonElement result = await _cache.GetOrSetAsync<JsonElement>(queryExecutor, queryMetadata, cacheEntryTtl: runtimeConfig.GetEntityCacheEntryTtl(entityName: structure.EntityName));
+                    byte[] jsonBytes = JsonSerializer.SerializeToUtf8Bytes(result);
+                    JsonDocument cacheServiceResponse = JsonDocument.Parse(jsonBytes);
+                    return cacheServiceResponse;
+                }
+            }
+
+            JsonDocument? response = await queryExecutor.ExecuteQueryAsync(
+                sqltext: queryString,
+                parameters: structure.Parameters,
+                dataReaderHandler: queryExecutor.GetJsonResultAsync<JsonDocument>,
+                httpContext: _httpContextAccessor.HttpContext!,
+                args: null,
+                dataSourceName: dataSourceName);
+            return response;
         }
 
         // <summary>