< 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: 200
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.Extensions;
 8using Elsa.Identity.Models;
 9using Elsa.Workflows;
 10
 11namespace Elsa.ExternalAuthentication.Services;
 12
 13/// <summary>
 14/// Provides a replaceable single-node implementation of atomic external identity linking and just-in-time provisioning.
 15/// Durable, multi-node hosts should replace this service with a transactional provisioner.
 16/// </summary>
 8917public sealed class InMemoryExternalIdentityProvisioner(
 8918    IUserStore userStore,
 8919    IUserProvider userProvider,
 8920    IRoleProvider roleProvider,
 8921    IIdentityGenerator identityGenerator,
 8922    ISystemClock clock,
 8923    IExternalAuthenticationHandleHasher handleHasher,
 8924    InMemoryExternalIdentityProvisionerState state) : IExternalIdentityProvisioner, IExternalIdentityLinkManagementStore
 25{
 8926    private readonly ExternalIdentityUserProvisioningService _userProvisioningService = new(userStore, userProvider, rol
 27
 28    public async ValueTask<ExternalIdentityLink?> FindLinkAsync(string tenantId, string connectionKey, ExternalIdentity 
 29    {
 1230        cancellationToken.ThrowIfCancellationRequested();
 1231        var key = new ExternalIdentityKey(tenantId, ConnectionRevisionCalculator.NormalizeKey(connectionKey), identity.I
 32
 1233        await state.Mutex.WaitAsync(cancellationToken);
 34        try
 35        {
 1236            return state.Links.TryGetValue(key, out var link) ? link : null;
 37        }
 38        finally
 39        {
 1240            state.Mutex.Release();
 41        }
 1242    }
 43
 44    public async ValueTask<ProvisioningResult> CreateLinkOrGetExistingAsync(ProvisioningRequest request, CancellationTok
 45    {
 4646        ArgumentNullException.ThrowIfNull(request);
 4647        cancellationToken.ThrowIfCancellationRequested();
 4648        var subjectHash = handleHasher.Hash(request.Identity.Subject);
 4649        var key = new ExternalIdentityKey(request.TenantId, ConnectionRevisionCalculator.NormalizeKey(request.Connection
 50
 4651        await state.Mutex.WaitAsync(cancellationToken);
 52        try
 53        {
 4654            if (state.Links.TryGetValue(key, out var existingLink))
 1855                return new ProvisioningResult(existingLink.UserId, existingLink, false);
 56
 2857            var (user, wasCreated) = await _userProvisioningService.ResolveAsync(request, state.ReservedUserNames.Add, c
 2758            var link = new ExternalIdentityLink(
 2759                identityGenerator.GenerateId(),
 2760                request.TenantId,
 2761                ConnectionRevisionCalculator.NormalizeKey(request.ConnectionKey),
 2762                request.Identity.Issuer,
 2763                subjectHash,
 2764                null,
 2765                user.Id,
 2766                clock.UtcNow,
 2767                null);
 2768            state.Links[key] = link;
 2769            if (!await _userProvisioningService.ExistsAsync(user, wasCreated, CancellationToken.None))
 70            {
 171                state.Links.Remove(key);
 172                throw new InvalidOperationException("The Elsa user was deleted while its external identity link was bein
 73            }
 2674            return new ProvisioningResult(user.Id, link, wasCreated, true);
 75        }
 76        finally
 77        {
 4678            state.Mutex.Release();
 79        }
 4480    }
 81
 82    public async ValueTask<bool> RecordSuccessfulSignInAsync(
 83        string tenantId,
 84        string connectionKey,
 85        ExternalIdentity identity,
 86        string userId,
 87        DateTimeOffset signedInAt,
 88        CancellationToken cancellationToken = default)
 89    {
 590        cancellationToken.ThrowIfCancellationRequested();
 591        var key = new ExternalIdentityKey(tenantId, ConnectionRevisionCalculator.NormalizeKey(connectionKey), identity.I
 92
 593        await state.Mutex.WaitAsync(cancellationToken);
 94        try
 95        {
 596            if (!state.Links.TryGetValue(key, out var link) || !string.Equals(link.UserId, userId, StringComparison.Ordi
 097                return false;
 98
 599            if (link.LastSignedInAt is null || link.LastSignedInAt < signedInAt)
 5100                state.Links[key] = link with { LastSignedInAt = signedInAt };
 5101            return true;
 102        }
 103        finally
 104        {
 5105            state.Mutex.Release();
 106        }
 5107    }
 108
 109    public async ValueTask<ExternalIdentityLinkReplaceResult> ReplaceAsync(ExternalIdentityLinkReplaceRequest request, C
 110    {
 8111        ArgumentNullException.ThrowIfNull(request);
 8112        cancellationToken.ThrowIfCancellationRequested();
 8113        var normalizedConnectionKey = ConnectionRevisionCalculator.NormalizeKey(request.ConnectionKey);
 8114        var replacementKey = new ExternalIdentityKey(request.TenantId, normalizedConnectionKey, request.Identity.Issuer,
 115
 8116        await state.Mutex.WaitAsync(cancellationToken);
 117        try
 118        {
 8119            var oldEntry = state.Links.FirstOrDefault(x =>
 18120                string.Equals(x.Value.Id, request.LinkId, StringComparison.Ordinal) &&
 18121                string.Equals(x.Value.TenantId, request.TenantId, StringComparison.Ordinal));
 8122            if (oldEntry.Equals(default(KeyValuePair<ExternalIdentityKey, ExternalIdentityLink>)))
 1123                return new ExternalIdentityLinkReplaceResult.NotFound();
 124
 7125            if (state.Links.TryGetValue(replacementKey, out var conflictingLink) &&
 7126                !string.Equals(conflictingLink.Id, oldEntry.Value.Id, StringComparison.Ordinal))
 2127                return new ExternalIdentityLinkReplaceResult.Conflict(oldEntry.Value, conflictingLink);
 128
 5129            var (user, _) = await _userProvisioningService.ResolveAsync(
 5130                new ProvisioningRequest(request.TenantId, normalizedConnectionKey, request.Identity, null, request.UserI
 5131                cancellationToken: cancellationToken);
 5132            var replacement = new ExternalIdentityLink(
 5133                identityGenerator.GenerateId(),
 5134                request.TenantId,
 5135                normalizedConnectionKey,
 5136                request.Identity.Issuer,
 5137                replacementKey.SubjectHash,
 5138                null,
 5139                user.Id,
 5140                clock.UtcNow,
 5141                null);
 5142            state.Links.Remove(oldEntry.Key);
 5143            state.Links[replacementKey] = replacement;
 5144            if (!await _userProvisioningService.ExistsAsync(user, false, CancellationToken.None))
 145            {
 1146                state.Links.Remove(replacementKey);
 1147                state.Links[oldEntry.Key] = oldEntry.Value;
 1148                var previousUser = new User { Id = oldEntry.Value.UserId, TenantId = oldEntry.Value.TenantId };
 1149                if (!await _userProvisioningService.ExistsAsync(previousUser, false, CancellationToken.None))
 1150                    state.Links.Remove(oldEntry.Key);
 1151                throw new InvalidOperationException("The Elsa user was deleted while its external identity link was bein
 152            }
 4153            return new ExternalIdentityLinkReplaceResult.Success(oldEntry.Value, replacement);
 154        }
 155        finally
 156        {
 8157            state.Mutex.Release();
 158        }
 7159    }
 160
 161    public async ValueTask<Page<ExternalIdentityLink>> FindAsync(ExternalIdentityLinkFilter filter, CancellationToken ca
 162    {
 14163        ArgumentNullException.ThrowIfNull(filter);
 14164        cancellationToken.ThrowIfCancellationRequested();
 165
 14166        await state.Mutex.WaitAsync(cancellationToken);
 167        try
 168        {
 14169            var links = state.Links.Values
 17170                .Where(x => string.Equals(x.TenantId, filter.TenantId, StringComparison.Ordinal))
 15171                .Where(x => filter.UserId is null || string.Equals(x.UserId, filter.UserId, StringComparison.Ordinal))
 15172                .Where(x => filter.ConnectionKey is null || string.Equals(x.ConnectionKey, ConnectionRevisionCalculator.
 10173                .OrderBy(x => x.CreatedAt)
 10174                .ThenBy(x => x.Id, StringComparer.Ordinal)
 14175                .ToArray();
 14176            return Page.Of<ExternalIdentityLink>(links, links.Length);
 177        }
 178        finally
 179        {
 14180            state.Mutex.Release();
 181        }
 14182    }
 183
 184    public async ValueTask<bool> DeleteAsync(string tenantId, string linkId, CancellationToken cancellationToken = defau
 185    {
 1186        cancellationToken.ThrowIfCancellationRequested();
 187
 1188        await state.Mutex.WaitAsync(cancellationToken);
 189        try
 190        {
 2191            var entry = state.Links.FirstOrDefault(x => string.Equals(x.Value.Id, linkId, StringComparison.Ordinal) && s
 1192            return !entry.Equals(default(KeyValuePair<ExternalIdentityKey, ExternalIdentityLink>)) && state.Links.Remove
 193        }
 194        finally
 195        {
 1196            state.Mutex.Release();
 197        }
 1198    }
 199
 200}
Generated by: ReportGenerator 5.5.11.0
08/19/2026 - 21:36:36
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()