< Summary

Information
Class: Elsa.ExternalAuthentication.Services.InMemoryExternalIdentityProvisioner
Assembly: Elsa.ExternalAuthentication
File(s): /home/runner/work/elsa-core/elsa-core/src/modules/Elsa.ExternalAuthentication/Services/InMemoryExternalIdentityProvisioner.cs
Line coverage
99%
Covered lines: 106
Uncovered lines: 1
Coverable lines: 107
Total lines: 198
Line coverage: 99%
Branch coverage
85%
Covered branches: 34
Total branches: 40
Branch coverage: 85%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
FindLinkAsync()100%22100%
CreateLinkOrGetExistingAsync()83.33%6696%
RecordSuccessfulSignInAsync()70%101090%
ReplaceAsync()75%121288.88%
FindAsync()100%11100%
DeleteAsync()50%22100%

File(s)

/home/runner/work/elsa-core/elsa-core/src/modules/Elsa.ExternalAuthentication/Services/InMemoryExternalIdentityProvisioner.cs

#LineLine coverage
 1using Elsa.Common;
 2using Elsa.Common.Models;
 3using Elsa.ExternalAuthentication.Contracts;
 4using Elsa.ExternalAuthentication.Models;
 5using Elsa.Identity.Contracts;
 6using Elsa.Identity.Entities;
 7using Elsa.Workflows;
 8
 9namespace Elsa.ExternalAuthentication.Services;
 10
 11/// <summary>
 12/// Provides a replaceable single-node implementation of atomic external identity linking and just-in-time provisioning.
 13/// Durable, multi-node hosts should replace this service with a transactional provisioner.
 14/// </summary>
 8915public sealed class InMemoryExternalIdentityProvisioner(
 8916    IUserStore userStore,
 8917    IUserProvider userProvider,
 8918    IRoleProvider roleProvider,
 8919    IIdentityGenerator identityGenerator,
 8920    ISystemClock clock,
 8921    IExternalAuthenticationHandleHasher handleHasher,
 8922    InMemoryExternalIdentityProvisionerState state) : IExternalIdentityProvisioner, IExternalIdentityLinkManagementStore
 23{
 8924    private readonly ExternalIdentityUserProvisioningService _userProvisioningService = new(userStore, userProvider, rol
 25
 26    public async ValueTask<ExternalIdentityLink?> FindLinkAsync(string tenantId, string connectionKey, ExternalIdentity 
 27    {
 1228        cancellationToken.ThrowIfCancellationRequested();
 1229        var key = new ExternalIdentityKey(tenantId, ConnectionRevisionCalculator.NormalizeKey(connectionKey), identity.I
 30
 1231        await state.Mutex.WaitAsync(cancellationToken);
 32        try
 33        {
 1234            return state.Links.TryGetValue(key, out var link) ? link : null;
 35        }
 36        finally
 37        {
 1238            state.Mutex.Release();
 39        }
 1240    }
 41
 42    public async ValueTask<ProvisioningResult> CreateLinkOrGetExistingAsync(ProvisioningRequest request, CancellationTok
 43    {
 4644        ArgumentNullException.ThrowIfNull(request);
 4645        cancellationToken.ThrowIfCancellationRequested();
 4646        var subjectHash = handleHasher.Hash(request.Identity.Subject);
 4647        var key = new ExternalIdentityKey(request.TenantId, ConnectionRevisionCalculator.NormalizeKey(request.Connection
 48
 4649        await state.Mutex.WaitAsync(cancellationToken);
 50        try
 51        {
 4652            if (state.Links.TryGetValue(key, out var existingLink))
 1853                return new(existingLink.UserId, existingLink, false);
 54
 2855            var (user, wasCreated) = await _userProvisioningService.ResolveAsync(request, state.ReservedUserNames.Add, c
 2756            var link = new ExternalIdentityLink(
 2757                identityGenerator.GenerateId(),
 2758                request.TenantId,
 2759                ConnectionRevisionCalculator.NormalizeKey(request.ConnectionKey),
 2760                request.Identity.Issuer,
 2761                subjectHash,
 2762                null,
 2763                user.Id,
 2764                clock.UtcNow,
 2765                null);
 2766            state.Links[key] = link;
 2767            if (!await _userProvisioningService.ExistsAsync(user, wasCreated, CancellationToken.None))
 68            {
 169                state.Links.Remove(key);
 170                throw new InvalidOperationException("The Elsa user was deleted while its external identity link was bein
 71            }
 2672            return new(user.Id, link, wasCreated, true);
 73        }
 74        finally
 75        {
 4676            state.Mutex.Release();
 77        }
 4478    }
 79
 80    public async ValueTask<bool> RecordSuccessfulSignInAsync(
 81        string tenantId,
 82        string connectionKey,
 83        ExternalIdentity identity,
 84        string userId,
 85        DateTimeOffset signedInAt,
 86        CancellationToken cancellationToken = default)
 87    {
 588        cancellationToken.ThrowIfCancellationRequested();
 589        var key = new ExternalIdentityKey(tenantId, ConnectionRevisionCalculator.NormalizeKey(connectionKey), identity.I
 90
 591        await state.Mutex.WaitAsync(cancellationToken);
 92        try
 93        {
 594            if (!state.Links.TryGetValue(key, out var link) || !string.Equals(link.UserId, userId, StringComparison.Ordi
 095                return false;
 96
 597            if (link.LastSignedInAt is null || link.LastSignedInAt < signedInAt)
 598                state.Links[key] = link with { LastSignedInAt = signedInAt };
 599            return true;
 100        }
 101        finally
 102        {
 5103            state.Mutex.Release();
 104        }
 5105    }
 106
 107    public async ValueTask<ExternalIdentityLinkReplaceResult> ReplaceAsync(ExternalIdentityLinkReplaceRequest request, C
 108    {
 8109        ArgumentNullException.ThrowIfNull(request);
 8110        cancellationToken.ThrowIfCancellationRequested();
 8111        var normalizedConnectionKey = ConnectionRevisionCalculator.NormalizeKey(request.ConnectionKey);
 8112        var replacementKey = new ExternalIdentityKey(request.TenantId, normalizedConnectionKey, request.Identity.Issuer,
 113
 8114        await state.Mutex.WaitAsync(cancellationToken);
 115        try
 116        {
 8117            var oldEntry = state.Links.FirstOrDefault(x =>
 18118                string.Equals(x.Value.Id, request.LinkId, StringComparison.Ordinal) &&
 18119                string.Equals(x.Value.TenantId, request.TenantId, StringComparison.Ordinal));
 8120            if (oldEntry.Equals(default(KeyValuePair<ExternalIdentityKey, ExternalIdentityLink>)))
 1121                return new ExternalIdentityLinkReplaceResult.NotFound();
 122
 7123            if (state.Links.TryGetValue(replacementKey, out var conflictingLink) &&
 7124                !string.Equals(conflictingLink.Id, oldEntry.Value.Id, StringComparison.Ordinal))
 2125                return new ExternalIdentityLinkReplaceResult.Conflict(oldEntry.Value, conflictingLink);
 126
 5127            var (user, _) = await _userProvisioningService.ResolveAsync(
 5128                new(request.TenantId, normalizedConnectionKey, request.Identity, null, request.UserId),
 5129                cancellationToken: cancellationToken);
 5130            var replacement = new ExternalIdentityLink(
 5131                identityGenerator.GenerateId(),
 5132                request.TenantId,
 5133                normalizedConnectionKey,
 5134                request.Identity.Issuer,
 5135                replacementKey.SubjectHash,
 5136                null,
 5137                user.Id,
 5138                clock.UtcNow,
 5139                null);
 5140            state.Links.Remove(oldEntry.Key);
 5141            state.Links[replacementKey] = replacement;
 5142            if (!await _userProvisioningService.ExistsAsync(user, false, CancellationToken.None))
 143            {
 1144                state.Links.Remove(replacementKey);
 1145                state.Links[oldEntry.Key] = oldEntry.Value;
 1146                var previousUser = new User { Id = oldEntry.Value.UserId, TenantId = oldEntry.Value.TenantId };
 1147                if (!await _userProvisioningService.ExistsAsync(previousUser, false, CancellationToken.None))
 1148                    state.Links.Remove(oldEntry.Key);
 1149                throw new InvalidOperationException("The Elsa user was deleted while its external identity link was bein
 150            }
 4151            return new ExternalIdentityLinkReplaceResult.Success(oldEntry.Value, replacement);
 152        }
 153        finally
 154        {
 8155            state.Mutex.Release();
 156        }
 7157    }
 158
 159    public async ValueTask<Page<ExternalIdentityLink>> FindAsync(ExternalIdentityLinkFilter filter, CancellationToken ca
 160    {
 14161        ArgumentNullException.ThrowIfNull(filter);
 14162        cancellationToken.ThrowIfCancellationRequested();
 163
 14164        await state.Mutex.WaitAsync(cancellationToken);
 165        try
 166        {
 14167            var links = state.Links.Values
 17168                .Where(x => string.Equals(x.TenantId, filter.TenantId, StringComparison.Ordinal))
 15169                .Where(x => filter.UserId is null || string.Equals(x.UserId, filter.UserId, StringComparison.Ordinal))
 15170                .Where(x => filter.ConnectionKey is null || string.Equals(x.ConnectionKey, ConnectionRevisionCalculator.
 10171                .OrderBy(x => x.CreatedAt)
 10172                .ThenBy(x => x.Id, StringComparer.Ordinal)
 14173                .ToArray();
 14174            return Page.Of<ExternalIdentityLink>(links, links.Length);
 175        }
 176        finally
 177        {
 14178            state.Mutex.Release();
 179        }
 14180    }
 181
 182    public async ValueTask<bool> DeleteAsync(string tenantId, string linkId, CancellationToken cancellationToken = defau
 183    {
 1184        cancellationToken.ThrowIfCancellationRequested();
 185
 1186        await state.Mutex.WaitAsync(cancellationToken);
 187        try
 188        {
 2189            var entry = state.Links.FirstOrDefault(x => string.Equals(x.Value.Id, linkId, StringComparison.Ordinal) && s
 1190            return !entry.Equals(default(KeyValuePair<ExternalIdentityKey, ExternalIdentityLink>)) && state.Links.Remove
 191        }
 192        finally
 193        {
 1194            state.Mutex.Release();
 195        }
 1196    }
 197
 198}
Generated by: ReportGenerator 5.5.11.0
09/09/2026 - 11:01:42
GitHub | reportgenerator.io

Methods/Properties

.ctor(Elsa.Identity.Contracts.IUserStore,Elsa.Identity.Contracts.IUserProvider,Elsa.Identity.Contracts.IRoleProvider,Elsa.Workflows.IIdentityGenerator,Elsa.Common.ISystemClock,Elsa.ExternalAuthentication.Contracts.IExternalAuthenticationHandleHasher,Elsa.ExternalAuthentication.Services.InMemoryExternalIdentityProvisionerState)
FindLinkAsync()
CreateLinkOrGetExistingAsync()
RecordSuccessfulSignInAsync()
ReplaceAsync()
FindAsync()
DeleteAsync()