SwissLife-OSS · npavlyk82 · Feb 7, 2025 · gmiserez · Feb 10, 2025 · npavlyk82
diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
@@ -3,10 +3,10 @@
   "isRoot": true,
   "tools": {
     "dotnet-sonarscanner": {
-      "version": "4.10.0",
+      "version": "5.13.1",
       "commands": [
         "dotnet-sonarscanner"
       ]
     }
   }
-}
+}
diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml
@@ -11,7 +11,7 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v2
       - name: Setup .NET
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
           dotnet-version: |
             3
@@ -22,8 +22,8 @@ jobs:
         uses: swisslife-oss/actions/pull-request@main
         with:
           sonar_token: ${{ secrets.SONAR_TOKEN }}
-          sonar_project_key: 'SwissLife-OSS_HotChocolateExtensions'
-          sonar_project_name: 'hotchocolate-extensions'
+          sonar_project_key: 'SwissLife-OSS_Bewit'
+          sonar_project_name: 'bewit'
           pr_number: ${{ github.event.pull_request.number }}
           pr_source_branch: ${{ github.head_ref }}
           pr_target_branch: ${{ github.base_ref }}

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
@@ -27,7 +27,7 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v2
       - name: Setup .NET
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
           dotnet-version: |
             3

diff --git a/README.md b/README.md
@@ -40,7 +40,17 @@ ISchema schema = SchemaBuilder.New()
                 d.Name("Mutation");
                 d.Field("RequestAccessUrl")
                     .Type<NonNullType<StringType>>()
-                    .Resolver(ctx => $"{mvcApiUrl}/api/file/123")
+                    .Resolver(ctx =>
+                    {
+                        Dictionary<string, string> extraProperties = new()
+                        {
+                            ["foo"] = "bar"
+                        };
+
+                        ctx.AddBewitTokenExtraProperties(extraProperties);
+
+                        return $"{mvcApiUrl}/api/file/123";
+                    })
                     .UseBewitUrlProtection();
             }))
     .Create();

diff --git a/global.json b/global.json
@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "8.0.402"
+    "version": "8.0.405"
   }
 }
diff --git a/samples/Endpoint_SecuredUrl/Startup.cs b/samples/Endpoint_SecuredUrl/Startup.cs
@@ -60,7 +60,8 @@ public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
                         var id = c.Request.RouteValues.GetValueOrDefault("id");
 
                         BewitToken<string> token =
-                            await generator.GenerateBewitTokenAsync($"/download/{id}", default);
+                            await generator.GenerateBewitTokenAsync($"/download/{id}",
+                                new Dictionary<string, object>(), default);
 
                         string html = @$"<html><a href=""/download/{id}?bewit={token}"">download</a>
                                         <br>{(string)token}</html>";

diff --git a/samples/HotChocolate_SecuredArgument/Types/Mutation.cs b/samples/HotChocolate_SecuredArgument/Types/Mutation.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Bewit.Generation;
@@ -29,14 +30,18 @@ public async Task<string> InvalidateBewitTokens(
         public async Task<string> CreateBewitToken(string value)
         {
             return (await _fooPayloadGenerator
-                    .GenerateBewitTokenAsync(new FooPayload {Value = value}, default))
+                    .GenerateBewitTokenAsync(
+                        new FooPayload {Value = value},
+                        new Dictionary<string, object>(),
+                        default))
                 .ToString();
         }
 
         public async Task<string> CreateIdentifiableBewitToken(string identifier)
         {
             return (await _barPayloadGenerator
-                    .GenerateIdentifiableBewitTokenAsync(new BarPayload(), identifier, default))
+                    .GenerateIdentifiableBewitTokenAsync(
+                        new BarPayload(), identifier, new Dictionary<string, object>(), default))
                 .ToString();
         }
     }

diff --git a/src/Core/Token.cs b/src/Core/Token.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Newtonsoft.Json;
 
 namespace Bewit
@@ -22,6 +23,12 @@ protected Token(string nonce, DateTime expirationDate)
 
         public DateTime ExpirationDate { get; private set; }
 
+        [JsonIgnore]
+        public bool? IsDeleted { get; set; } = false;
+
+        [JsonIgnore]
+        public Dictionary<string, object> ExtraProperties { get; set; }
+
         public static Token Create(string nonce, DateTime expirationDate)
         {
             if (string.IsNullOrWhiteSpace(nonce))

diff --git a/src/Extensions.HotChocolate/Generation/BewitMiddleware.cs b/src/Extensions.HotChocolate/Generation/BewitMiddleware.cs
@@ -23,7 +23,8 @@ public async Task InvokeAsync(
             if (context.Result is TPayload result)
             {
                 BewitToken<TPayload> bewit
-                    = await tokenGenerator.GenerateBewitTokenAsync(result, context.RequestAborted);
+                    = await tokenGenerator.GenerateBewitTokenAsync(
+                        result, context.GetBewitTokenExtraProperties(), context.RequestAborted);
 
                 context.Result = (string)bewit;
             }

diff --git a/src/Extensions.HotChocolate/Generation/BewitTokenExtraPropertiesHelper.cs b/src/Extensions.HotChocolate/Generation/BewitTokenExtraPropertiesHelper.cs
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+using System.Linq;
+using HotChocolate.Resolvers;
+
+namespace Bewit.Extensions.HotChocolate.Generation;
+
+public static class BewitTokenExtraPropertiesHelper
+
+{
+    private const string ExtraPropertyPrefix = "BewitTokenExtraProperty:";
+
+    public static void AddBewitTokenExtraProperties(
+        this IResolverContext resolverContext, Dictionary<string, object> extraProperties)
+    {
+        if (extraProperties == null)
+        {
+            return;
+        }
+
+        resolverContext.ScopedContextData =
+             resolverContext.ScopedContextData.SetItems(
+                  extraProperties.ToDictionary(
+                      ctx => $"{ExtraPropertyPrefix}{ctx.Key}",
+                      ctx => ctx.Value));
+    }
+
+    public static Dictionary<string, object> GetBewitTokenExtraProperties(this IMiddlewareContext context)
+    {
+        Dictionary<string, object> extraProperties = new Dictionary<string, object>();
+
+        foreach (var key in context.ScopedContextData.Keys)
+        {
+            if (!key.StartsWith(ExtraPropertyPrefix))
+            {
+                continue;
+            }
+
+            object extraPropertyValue = context.ScopedContextData.GetValueOrDefault(key);
+
+            if (extraPropertyValue != null)
+            {
+                extraProperties.Add(
+                    key.Substring(ExtraPropertyPrefix.Length),
+                    extraPropertyValue);
+            }
+        }
+
+        return extraProperties;
+    }
+
+}
diff --git a/src/Extensions.HotChocolate/Generation/BewitUrlMiddleware.cs b/src/Extensions.HotChocolate/Generation/BewitUrlMiddleware.cs
@@ -29,7 +29,7 @@ public async Task InvokeAsync(
 
                 BewitToken<string> bewit =
                     await tokenGenerator.GenerateBewitTokenAsync(
-                        uri.PathAndQuery, context.RequestAborted);
+                        uri.PathAndQuery, context.GetBewitTokenExtraProperties(), context.RequestAborted);
 
                 var parametersToAdd = new Dictionary<string, string>
                 {

diff --git a/src/Generation/BewitTokenGenerator.cs b/src/Generation/BewitTokenGenerator.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Text;
 using System.Threading;
@@ -43,19 +44,24 @@ public BewitTokenGenerator(
 
         public Task<BewitToken<T>> GenerateBewitTokenAsync(
             T payload,
-            CancellationToken cancellationToken)
+            Dictionary<string, object> extraProperties,
+            CancellationToken cancellationToken
+            )
         {
             var token = Token.Create(CreateNextToken(), CreateExpirationDate());
+            token.ExtraProperties = extraProperties;
             return GenerateBewitTokenImplAsync(payload, token, cancellationToken);
 
         }
 
         public Task<BewitToken<T>> GenerateIdentifiableBewitTokenAsync(
             T payload,
             string identifier,
+            Dictionary<string, object> extraProperties,
             CancellationToken cancellationToken)
         {
             var token = new IdentifiableToken(identifier, CreateNextToken(), CreateExpirationDate());
+            token.ExtraProperties = extraProperties;
             return GenerateBewitTokenImplAsync(payload, token, cancellationToken);
         }
 

diff --git a/src/Generation/IBewitTokenGenerator.cs b/src/Generation/IBewitTokenGenerator.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -7,6 +8,7 @@ public interface IBewitTokenGenerator<T>
     {
         Task<BewitToken<T>> GenerateBewitTokenAsync(
             T payload,
+            Dictionary<string, object> extraProperties,
             CancellationToken cancellationToken);
     }
 }
diff --git a/src/Generation/IIdentifiableBewitTokenGenerator.cs b/src/Generation/IIdentifiableBewitTokenGenerator.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -8,6 +9,7 @@ public interface IIdentifiableBewitTokenGenerator<T>
     Task<BewitToken<T>> GenerateIdentifiableBewitTokenAsync(
         T payload,
         string identifier,
+        Dictionary<string, object> extraProperties,
         CancellationToken cancellationToken);
 
     Task InvalidateIdentifier(

diff --git a/src/Storage.MongoDB/MongoNonceOptions.cs b/src/Storage.MongoDB/MongoNonceOptions.cs
@@ -26,5 +26,8 @@ public class MongoNonceOptions
         /// ReUse will keep it in the storage.
         /// </summary>
         public NonceUsage NonceUsage { get; set; } = NonceUsage.OneTime;
+
+
+        public int RecordExpireAfterDays { get; set; } = 365 * 2;
     }
 }
diff --git a/src/Storage.MongoDB/MongoNonceRepository.cs b/src/Storage.MongoDB/MongoNonceRepository.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson.Serialization;
@@ -27,6 +29,8 @@ static MongoNonceRepository()
             {
                 cm.MapIdMember(c => c.Nonce);
                 cm.MapField(c => c.ExpirationDate);
+                cm.MapField(c => c.IsDeleted);
+                cm.MapField(c => c.ExtraProperties);
                 cm.SetIgnoreExtraElements(true);
             });
         }
@@ -38,24 +42,46 @@ public MongoNonceRepository(IMongoDatabase database, MongoNonceOptions options)
 
             _collection.Indexes.CreateOne(new CreateIndexModel<Token>(
                 Builders<Token>.IndexKeys.Ascending(nameof(IdentifiableToken.Identifier))));
+
+            _collection.Indexes.CreateOne(new CreateIndexModel<Token>(
+                Builders<Token>.IndexKeys.Ascending(nameof(Token.ExpirationDate)),
+                new CreateIndexOptions
+                {
+                    ExpireAfter = TimeSpan.FromDays(options.RecordExpireAfterDays)
+                }));
         }
 
         public async ValueTask InsertOneAsync(
             Token token, CancellationToken cancellationToken)
         {
+            token.ExtraProperties = token.ExtraProperties ?? new Dictionary<string, object>();
+
+            IReadOnlySet<string> propertyNamesWithPrimitiveValueType =
+                GetPropertyNamesWithPrimitiveValueType(token.ExtraProperties);
+
+            SetJsonStringValue(token.ExtraProperties, propertyNamesWithPrimitiveValueType);
+
             await _collection.InsertOneAsync(token, cancellationToken: cancellationToken);
+
+            CreateIndexes(propertyNamesWithPrimitiveValueType);
         }
 
         public async ValueTask<Token?> TakeOneAsync(
             string token,
             CancellationToken cancellationToken)
         {
-            FilterDefinition<Token> findFilter = Builders<Token>.Filter.Eq(n => n.Nonce, token);
+            FilterDefinition<Token> findFilter =
+                Builders<Token>.Filter.Eq(n => n.Nonce, token) &
+                (Builders<Token>.Filter.Not(Builders<Token>.Filter.Exists(n => n.IsDeleted)) |
+                 Builders<Token>.Filter.Eq(n => n.IsDeleted, false));
+
+            UpdateDefinition<Token> updateDefinition =
+                Builders<Token>.Update.Set(x => x.IsDeleted, true);
 
             if (_options.NonceUsage == NonceUsage.OneTime)
             {
                 return await _collection
-                    .FindOneAndDeleteAsync(findFilter, cancellationToken: cancellationToken);
+                    .FindOneAndUpdateAsync(findFilter, updateDefinition, cancellationToken: cancellationToken);
             }
 
             return await _collection
@@ -77,5 +103,52 @@ public static void Initialize()
         {
             //ensure static constructor is called
         }
+
+        private void CreateIndexes(IEnumerable<string> extraPropertyNames)
+        {
+            var indexOptions = new CreateIndexOptions { Background = true };
+
+            foreach (string extraPropertyName in extraPropertyNames)
+            {
+                _collection.Indexes.CreateOne(new CreateIndexModel<Token>(
+                    Builders<Token>.IndexKeys.Ascending(
+                        $"{nameof(Token.ExtraProperties)}.{extraPropertyName}"), indexOptions));
+            }
+        }
+
+        private IReadOnlySet<string> GetPropertyNamesWithPrimitiveValueType(
+            Dictionary<string, object> extraProperties)
+        {
+            HashSet<string> names = new HashSet<string>();
+
+            foreach (KeyValuePair<string, object> keyValue in extraProperties)
+            {
+                if (keyValue.Value == null)
+                {
+                    continue;
+                }
+
+                if (TypeChecker.IsPrimitiveType(keyValue.Value.GetType()))
+                {
+                    names.Add(keyValue.Key);
+                }
+            }
+
+            return names;
+        }
+
+        private void SetJsonStringValue(
+            Dictionary<string, object> extraProperties, IReadOnlySet<string> namesToSkip)
+        {
+            foreach(string name in extraProperties.Keys)
+            {
+                if (namesToSkip.Contains(name))
+                {
+                    continue;
+                }
+
+                extraProperties[name] = JsonSerializer.Serialize(extraProperties[name]);
+            }
+        }
     }
 }