< 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>
 9815public sealed class InMemoryExternalIdentityProvisioner(
 9816    IUserStore userStore,
 9817    IUserProvider userProvider,
 9818    IRoleProvider roleProvider,
 9819    IIdentityGenerator identityGenerator,
 9820    ISystemClock clock,
 9821    IExternalAuthenticationHandleHasher handleHasher,
 9822    InMemoryExternalIdentityProvisionerState state) : IExternalIdentityProvisioner, IExternalIdentityLinkManagementStore
 23{
 9824    private readonly ExternalIdentityUserProvisioningService _userProvisioningService = new(userStore, userProvider, rol
 25
 26    public async ValueTask<ExternalIdentityLink?> FindLinkAsync(string tenantId, string connectionKey, ExternalIdentity 
 27    {
 1928        cancellationToken.ThrowIfCancellationRequested();
 1929        var key = new ExternalIdentityKey(tenantId, ConnectionRevisionCalculator.NormalizeKey(connectionKey), identity.I
 30
 1931        await state.Mutex.WaitAsync(cancellationToken);
 32        try
 33        {
 1934            return state.Links.TryGetValue(key, out var link) ? link : null;
 35        }
 36        finally
 37        {
 1938            state.Mutex.Release();
 39        }
 1940    }
 41
 42    public async ValueTask<ProvisioningResult> CreateLinkOrGetExistingAsync(ProvisioningRequest request, CancellationTok
 43    {
 5244        ArgumentNullException.ThrowIfNull(request);
 5245        cancellationToken.ThrowIfCancellationRequested();
 5246        var subjectHash = handleHasher.Hash(request.Identity.Subject);
 5247        var key = new ExternalIdentityKey(request.TenantId, ConnectionRevisionCalculator.NormalizeKey(request.Connection
 48
 5249        await state.Mutex.WaitAsync(cancellationToken);
 50        try
 51        {
 5252            if (state.Links.TryGetValue(key, out var existingLink))
 2053                return new(existingLink.UserId, existingLink, false);
 54
 3255            var (user, wasCreated) = await _userProvisioningService.ResolveAsync(request, state.ReservedUserNames.Add, c
 3156            var link = new ExternalIdentityLink(
 3157                identityGenerator.GenerateId(),
 3158                request.TenantId,
 3159                ConnectionRevisionCalculator.NormalizeKey(request.ConnectionKey),
 3160                request.Identity.Issuer,
 3161                subjectHash,
 3162                null,
 3163                user.Id,
 3164                clock.UtcNow,
 3165                null);
 3166            state.Links[key] = link;
 3167            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            }
 3072            return new(user.Id, link, wasCreated, true);
 73        }
 74        finally
 75        {
 5276            state.Mutex.Release();
 77        }
 5078    }
 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    {
 12109        ArgumentNullException.ThrowIfNull(request);
 12110        cancellationToken.ThrowIfCancellationRequested();
 12111        var normalizedConnectionKey = ConnectionRevisionCalculator.NormalizeKey(request.ConnectionKey);
 12112        var replacementKey = new ExternalIdentityKey(request.TenantId, normalizedConnectionKey, request.Identity.Issuer,
 113
 12114        await state.Mutex.WaitAsync(cancellationToken);
 115        try
 116        {
 12117            var oldEntry = state.Links.FirstOrDefault(x =>
 26118                string.Equals(x.Value.Id, request.LinkId, StringComparison.Ordinal) &&
 26119                string.Equals(x.Value.TenantId, request.TenantId, StringComparison.Ordinal));
 12120            if (oldEntry.Equals(default(KeyValuePair<ExternalIdentityKey, ExternalIdentityLink>)))
 2121                return new ExternalIdentityLinkReplaceResult.NotFound();
 122
 10123            if (state.Links.TryGetValue(replacementKey, out var conflictingLink) &&
 10124                !string.Equals(conflictingLink.Id, oldEntry.Value.Id, StringComparison.Ordinal))
 3125                return new ExternalIdentityLinkReplaceResult.Conflict(oldEntry.Value, conflictingLink);
 126
 7127            var (user, _) = await _userProvisioningService.ResolveAsync(
 7128                new(request.TenantId, normalizedConnectionKey, request.Identity, null, request.UserId),
 7129                cancellationToken: cancellationToken);
 7130            var replacement = new ExternalIdentityLink(
 7131                identityGenerator.GenerateId(),
 7132                request.TenantId,
 7133                normalizedConnectionKey,
 7134                request.Identity.Issuer,
 7135                replacementKey.SubjectHash,
 7136                null,
 7137                user.Id,
 7138                clock.UtcNow,
 7139                null);
 7140            state.Links.Remove(oldEntry.Key);
 7141            state.Links[replacementKey] = replacement;
 7142            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            }
 6151            return new ExternalIdentityLinkReplaceResult.Success(oldEntry.Value, replacement);
 152        }
 153        finally
 154        {
 12155            state.Mutex.Release();
 156        }
 11157    }
 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/26/2026 - 05:55:48
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()