Add editorconfig and analyzers, format backend code

backend/Core/Musify.Application/Users/CreateUser.cs

@@ -6,54 +6,53 @@ using Musify.Application.Contracts;
 using Musify.Application.Users.Responses;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record CreateUserCommand(long Id,
+    string Name,
+    string? FirstName,
+    string? SecondName)
+    : ICommand<ErrorOr<UserApplicationResponse>>
 {
-    public record CreateUserCommand(long Id,
-        string Name,
-        string? FirstName,
-        string? SecondName)
-        : ICommand<ErrorOr<UserApplicationResponse>>
+    public static User ToEntity(CreateUserCommand command)
     {
-        public static User ToEntity(CreateUserCommand command)
+        return new User
         {
-            return new User
-            {
-                Id = command.Id,
-                Name = command.Name,
-                NormalizedName = command.Name.ToUpperInvariant(),
-                FirstName = command.FirstName,
-                SecondName = command.SecondName
-            };
-        }
+            Id = command.Id,
+            Name = command.Name,
+            NormalizedName = command.Name.ToUpperInvariant(),
+            FirstName = command.FirstName,
+            SecondName = command.SecondName
+        };
     }
+}
 
-    public class CreateUserCommandHandler(IDatabase database, ILogger<CreateUserCommandHandler> logger)
-        : ICommandHandler<CreateUserCommand, ErrorOr<UserApplicationResponse>>
+public class CreateUserCommandHandler(IDatabase database, ILogger<CreateUserCommandHandler> logger)
+    : ICommandHandler<CreateUserCommand, ErrorOr<UserApplicationResponse>>
+{
+    public async ValueTask<ErrorOr<UserApplicationResponse>> Handle(CreateUserCommand request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<UserApplicationResponse>> Handle(CreateUserCommand request, CancellationToken cancellationToken)
+        var userExists = await database.Users.AnyAsync(u => u.Id == request.Id, cancellationToken);
+        if (userExists)
         {
-            var userExists = await database.Users.AnyAsync(u => u.Id == request.Id, cancellationToken);
-            if (userExists)
-            {
-                logger.LogInformation("User {UserId} already exists", request.Id);
-                return Error.Conflict(description: $"User {request.Id} already exists");
-            }
+            logger.LogInformation("User {UserId} already exists", request.Id);
+            return Error.Conflict(description: $"User {request.Id} already exists");
+        }
 
-            var newUser = CreateUserCommand.ToEntity(request);
+        var newUser = CreateUserCommand.ToEntity(request);
 
-            try
-            {
-                await database.Users.AddAsync(newUser, cancellationToken);
-                await database.SaveChangesAsync(cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to create user {UserId}", request.Id);
-                return Error.Failure(description: $"Failed to create user {request.Id}");
-            }
+        try
+        {
+            await database.Users.AddAsync(newUser, cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
+        }
+        catch (Exception exception)
+        {
+            logger.LogError(exception, "Failed to create user {UserId}", request.Id);
+            return Error.Failure(description: $"Failed to create user {request.Id}");
+        }
 
-            logger.LogInformation("Created user {UserId}", newUser.Id);
-            return UserApplicationResponse.FromEntity(newUser);
-        }
+        logger.LogInformation("Created user {UserId}", newUser.Id);
+        return UserApplicationResponse.FromEntity(newUser);
     }
 }

backend/Core/Musify.Application/Users/FollowUser.cs

@@ -5,46 +5,45 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record FollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
+
+public class FollowUserCommandHandler(
+    IDatabase database,
+    ILogger<FollowUserCommandHandler> logger)
+    : ICommandHandler<FollowUserCommand, ErrorOr<Success>>
 {
-    public record FollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
-
-    public class FollowUserCommandHandler(
-        IDatabase database,
-        ILogger<FollowUserCommandHandler> logger)
-        : ICommandHandler<FollowUserCommand, ErrorOr<Success>>
+    public async ValueTask<ErrorOr<Success>> Handle(FollowUserCommand request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<Success>> Handle(FollowUserCommand request, CancellationToken cancellationToken)
+        if (request.FollowerId == request.FollowedId)
+            return Error.Validation(description: "A user cannot follow themselves.");
+
+        var followedExists = await database.Users
+            .AsNoTracking()
+            .AnyAsync(u => u.Id == request.FollowedId, cancellationToken);
+        if (!followedExists)
         {
-            if (request.FollowerId == request.FollowedId)
-                return Error.Validation(description: "A user cannot follow themselves.");
-
-            var followedExists = await database.Users
-                .AsNoTracking()
-                .AnyAsync(u => u.Id == request.FollowedId, cancellationToken);
-            if (!followedExists)
-            {
-                logger.LogInformation("User {FollowedId} not found", request.FollowedId);
-                return Error.NotFound(description: $"User {request.FollowedId} not found");
-            }
-
-            var alreadyFollowing = await database.UserFollows
-                .AsNoTracking()
-                .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
-            if (alreadyFollowing)
-                return new Success();
-
-            await database.UserFollows.AddAsync(new UserFollow
-            {
-                FollowerId = request.FollowerId,
-                FollowedId = request.FollowedId
-            }, cancellationToken);
-
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("User {FollowerId} followed user {FollowedId}", request.FollowerId, request.FollowedId);
-
-            return new Success();
+            logger.LogInformation("User {FollowedId} not found", request.FollowedId);
+            return Error.NotFound(description: $"User {request.FollowedId} not found");
         }
+
+        var alreadyFollowing = await database.UserFollows
+            .AsNoTracking()
+            .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
+        if (alreadyFollowing)
+            return new Success();
+
+        await database.UserFollows.AddAsync(new UserFollow
+        {
+            FollowerId = request.FollowerId,
+            FollowedId = request.FollowedId
+        }, cancellationToken);
+
+        await database.SaveChangesAsync(cancellationToken);
+
+        logger.LogInformation("User {FollowerId} followed user {FollowedId}", request.FollowerId, request.FollowedId);
+
+        return new Success();
     }
 }

backend/Core/Musify.Application/Users/FollowVisibility.cs

@@ -1,30 +1,29 @@
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public static class FollowVisibility
 {
-    public static class FollowVisibility
+    public static async Task<bool> CanViewFollowersAsync(
+        IDatabase database,
+        long? viewerId,
+        long userId,
+        CancellationToken cancellationToken)
     {
-        public static async Task<bool> CanViewFollowersAsync(
-            IDatabase database,
-            long? viewerId,
-            long userId,
-            CancellationToken cancellationToken)
-        {
-            if (viewerId is not { } viewer)
-                return false;
+        if (viewerId is not { } viewer)
+            return false;
 
-            if (viewer == userId)
-                return true;
+        if (viewer == userId)
+            return true;
 
-            var mutualRows = await database.UserFollows
-                .AsNoTracking()
-                .CountAsync(f =>
-                    (f.FollowerId == viewer && f.FollowedId == userId) ||
-                    (f.FollowerId == userId && f.FollowedId == viewer),
-                    cancellationToken);
+        var mutualRows = await database.UserFollows
+            .AsNoTracking()
+            .CountAsync(f =>
+                (f.FollowerId == viewer && f.FollowedId == userId) ||
+                (f.FollowerId == userId && f.FollowedId == viewer),
+                cancellationToken);
 
-            return mutualRows == 2;
-        }
+        return mutualRows == 2;
     }
 }

backend/Core/Musify.Application/Users/GetListeningStats.cs

@@ -2,50 +2,49 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record GetListeningStatsQuery(long UserId) : IQuery<ListeningStatsResponse>;
+
+public record ListeningStatsResponse(int TracksThisWeek, int SecondsThisWeek, int StreakDays);
+
+public class GetListeningStatsQueryHandler(IDatabase database)
+    : IQueryHandler<GetListeningStatsQuery, ListeningStatsResponse>
 {
-    public record GetListeningStatsQuery(long UserId) : IQuery<ListeningStatsResponse>;
-
-    public record ListeningStatsResponse(int TracksThisWeek, int SecondsThisWeek, int StreakDays);
-
-    public class GetListeningStatsQueryHandler(IDatabase database)
-        : IQueryHandler<GetListeningStatsQuery, ListeningStatsResponse>
+    public async ValueTask<ListeningStatsResponse> Handle(GetListeningStatsQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ListeningStatsResponse> Handle(GetListeningStatsQuery request, CancellationToken cancellationToken)
+        var weekAgo = DateTime.UtcNow.AddDays(-7);
+
+        var thisWeekHistory = database.ListeningHistories
+            .AsNoTracking()
+            .Where(l => l.UserId == request.UserId && l.ListenedAt >= weekAgo);
+
+        var tracksThisWeek = await thisWeekHistory
+            .Where(l => l.IsCounted)
+            .Select(l => l.TrackId)
+            .Distinct()
+            .CountAsync(cancellationToken);
+
+        var secondsThisWeek = await thisWeekHistory
+            .Join(database.Tracks.AsNoTracking(), l => l.TrackId, t => t.Id, (l, t) => l.PlayedSeconds ?? (l.IsCounted ? t.DurationSeconds : 0))
+            .SumAsync(cancellationToken);
+
+        var listenedDates = await database.ListeningHistories
+            .AsNoTracking()
+            .Where(l => l.UserId == request.UserId && l.IsCounted)
+            .Select(l => l.ListenedAt.Date)
+            .Distinct()
+            .ToListAsync(cancellationToken);
+
+        var listenedDateSet = listenedDates.ToHashSet();
+        var streakDays = 0;
+        var day = DateTime.UtcNow.Date;
+        while (listenedDateSet.Contains(day))
         {
-            var weekAgo = DateTime.UtcNow.AddDays(-7);
-
-            var thisWeekHistory = database.ListeningHistories
-                .AsNoTracking()
-                .Where(l => l.UserId == request.UserId && l.ListenedAt >= weekAgo);
-
-            var tracksThisWeek = await thisWeekHistory
-                .Where(l => l.IsCounted)
-                .Select(l => l.TrackId)
-                .Distinct()
-                .CountAsync(cancellationToken);
-
-            var secondsThisWeek = await thisWeekHistory
-                .Join(database.Tracks.AsNoTracking(), l => l.TrackId, t => t.Id, (l, t) => l.PlayedSeconds ?? (l.IsCounted ? t.DurationSeconds : 0))
-                .SumAsync(cancellationToken);
-
-            var listenedDates = await database.ListeningHistories
-                .AsNoTracking()
-                .Where(l => l.UserId == request.UserId && l.IsCounted)
-                .Select(l => l.ListenedAt.Date)
-                .Distinct()
-                .ToListAsync(cancellationToken);
-
-            var listenedDateSet = listenedDates.ToHashSet();
-            var streakDays = 0;
-            var day = DateTime.UtcNow.Date;
-            while (listenedDateSet.Contains(day))
-            {
-                streakDays++;
-                day = day.AddDays(-1);
-            }
-
-            return new ListeningStatsResponse(tracksThisWeek, (int)Math.Round(secondsThisWeek), streakDays);
+            streakDays++;
+            day = day.AddDays(-1);
         }
+
+        return new ListeningStatsResponse(tracksThisWeek, (int)Math.Round(secondsThisWeek), streakDays);
     }
 }

backend/Core/Musify.Application/Users/GetUserById.cs

@@ -4,26 +4,25 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Users.Responses;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record GetUserByIdQuery(long Id)
+    : IQuery<ErrorOr<UserApplicationResponse>>;
+
+public class GetUserByIdQueryHandler(IDatabase database)
+    : IQueryHandler<GetUserByIdQuery, ErrorOr<UserApplicationResponse>>
 {
-    public record GetUserByIdQuery(long Id)
-        : IQuery<ErrorOr<UserApplicationResponse>>;
-
-    public class GetUserByIdQueryHandler(IDatabase database)
-        : IQueryHandler<GetUserByIdQuery, ErrorOr<UserApplicationResponse>>
+    public async ValueTask<ErrorOr<UserApplicationResponse>> Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<UserApplicationResponse>> Handle(GetUserByIdQuery request, CancellationToken cancellationToken)
-        {
-            var user = await database.Users
-                .AsNoTracking()
-                .Where(u => u.Id == request.Id)
-                .Select(u => UserApplicationResponse.FromEntity(u))
-                .SingleOrDefaultAsync(cancellationToken);
+        var user = await database.Users
+            .AsNoTracking()
+            .Where(u => u.Id == request.Id)
+            .Select(u => UserApplicationResponse.FromEntity(u))
+            .SingleOrDefaultAsync(cancellationToken);
 
-            if (user == null)
-                return Error.NotFound();
+        if (user == null)
+            return Error.NotFound();
 
-            return user;
-        }
+        return user;
     }
 }

backend/Core/Musify.Application/Users/GetUserFollowers.cs

@@ -6,41 +6,40 @@ using Musify.Application.Shared;
 using Musify.Application.Users.Responses;
 using X.PagedList.EF;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record GetUserFollowersQuery(long? ViewerId, long UserId, int PageNumber, int PageSize)
+    : IQuery<ErrorOr<PaginatedResponse<UserSummaryResponse>>>;
+
+public class GetUserFollowersQueryHandler(IDatabase database)
+    : IQueryHandler<GetUserFollowersQuery, ErrorOr<PaginatedResponse<UserSummaryResponse>>>
 {
-    public record GetUserFollowersQuery(long? ViewerId, long UserId, int PageNumber, int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<UserSummaryResponse>>>;
-
-    public class GetUserFollowersQueryHandler(IDatabase database)
-        : IQueryHandler<GetUserFollowersQuery, ErrorOr<PaginatedResponse<UserSummaryResponse>>>
+    public async ValueTask<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Handle(GetUserFollowersQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Handle(GetUserFollowersQuery request, CancellationToken cancellationToken)
-        {
-            if (!await database.Users.AnyAsync(u => u.Id == request.UserId, cancellationToken))
-                return Error.NotFound();
+        if (!await database.Users.AnyAsync(u => u.Id == request.UserId, cancellationToken))
+            return Error.NotFound();
 
-            if (!await FollowVisibility.CanViewFollowersAsync(database, request.ViewerId, request.UserId, cancellationToken))
-                return Error.Forbidden();
+        if (!await FollowVisibility.CanViewFollowersAsync(database, request.ViewerId, request.UserId, cancellationToken))
+            return Error.Forbidden();
 
-            var followsQuery = database.UserFollows
-                .AsNoTracking()
-                .Where(f => f.FollowedId == request.UserId);
+        var followsQuery = database.UserFollows
+            .AsNoTracking()
+            .Where(f => f.FollowedId == request.UserId);
 
-            var totalCount = await followsQuery.CountAsync(cancellationToken);
-            var viewerId = request.ViewerId;
+        var totalCount = await followsQuery.CountAsync(cancellationToken);
+        var viewerId = request.ViewerId;
 
-            var page = await followsQuery
-                .OrderByDescending(f => f.CreatedAt)
-                .Select(f => new UserSummaryResponse(
-                    f.Follower.Id,
-                    f.Follower.Name,
-                    f.Follower.FirstName,
-                    f.Follower.SecondName,
-                    f.Follower.ProfilePictureUrl,
-                    viewerId != null && database.UserFollows.Any(v => v.FollowerId == viewerId && v.FollowedId == f.FollowerId)))
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+        var page = await followsQuery
+            .OrderByDescending(f => f.CreatedAt)
+            .Select(f => new UserSummaryResponse(
+                f.Follower.Id,
+                f.Follower.Name,
+                f.Follower.FirstName,
+                f.Follower.SecondName,
+                f.Follower.ProfilePictureUrl,
+                viewerId != null && database.UserFollows.Any(v => v.FollowerId == viewerId && v.FollowedId == f.FollowerId)))
+            .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
-            return PaginatedResponse<UserSummaryResponse>.FromPagedList(page);
-        }
+        return PaginatedResponse<UserSummaryResponse>.FromPagedList(page);
     }
 }

backend/Core/Musify.Application/Users/GetUserFollowing.cs

@@ -6,38 +6,37 @@ using Musify.Application.Shared;
 using Musify.Application.Users.Responses;
 using X.PagedList.EF;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record GetUserFollowingQuery(long? ViewerId, long UserId, int PageNumber, int PageSize)
+    : IQuery<ErrorOr<PaginatedResponse<UserSummaryResponse>>>;
+
+public class GetUserFollowingQueryHandler(IDatabase database)
+    : IQueryHandler<GetUserFollowingQuery, ErrorOr<PaginatedResponse<UserSummaryResponse>>>
 {
-    public record GetUserFollowingQuery(long? ViewerId, long UserId, int PageNumber, int PageSize)
-        : IQuery<ErrorOr<PaginatedResponse<UserSummaryResponse>>>;
-
-    public class GetUserFollowingQueryHandler(IDatabase database)
-        : IQueryHandler<GetUserFollowingQuery, ErrorOr<PaginatedResponse<UserSummaryResponse>>>
+    public async ValueTask<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Handle(GetUserFollowingQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Handle(GetUserFollowingQuery request, CancellationToken cancellationToken)
-        {
-            if (!await database.Users.AnyAsync(u => u.Id == request.UserId, cancellationToken))
-                return Error.NotFound();
+        if (!await database.Users.AnyAsync(u => u.Id == request.UserId, cancellationToken))
+            return Error.NotFound();
 
-            var followsQuery = database.UserFollows
-                .AsNoTracking()
-                .Where(f => f.FollowerId == request.UserId);
+        var followsQuery = database.UserFollows
+            .AsNoTracking()
+            .Where(f => f.FollowerId == request.UserId);
 
-            var totalCount = await followsQuery.CountAsync(cancellationToken);
-            var viewerId = request.ViewerId;
+        var totalCount = await followsQuery.CountAsync(cancellationToken);
+        var viewerId = request.ViewerId;
 
-            var page = await followsQuery
-                .OrderByDescending(f => f.CreatedAt)
-                .Select(f => new UserSummaryResponse(
-                    f.Followed.Id,
-                    f.Followed.Name,
-                    f.Followed.FirstName,
-                    f.Followed.SecondName,
-                    f.Followed.ProfilePictureUrl,
-                    viewerId != null && database.UserFollows.Any(v => v.FollowerId == viewerId && v.FollowedId == f.FollowedId)))
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+        var page = await followsQuery
+            .OrderByDescending(f => f.CreatedAt)
+            .Select(f => new UserSummaryResponse(
+                f.Followed.Id,
+                f.Followed.Name,
+                f.Followed.FirstName,
+                f.Followed.SecondName,
+                f.Followed.ProfilePictureUrl,
+                viewerId != null && database.UserFollows.Any(v => v.FollowerId == viewerId && v.FollowedId == f.FollowedId)))
+            .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
 
-            return PaginatedResponse<UserSummaryResponse>.FromPagedList(page);
-        }
+        return PaginatedResponse<UserSummaryResponse>.FromPagedList(page);
     }
 }

backend/Core/Musify.Application/Users/GetUserProfile.cs

@@ -5,71 +5,70 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 using Musify.Application.Serialization;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record GetUserProfileQuery(long UserId, long? ViewerId = null) : IQuery<ErrorOr<UserProfileResponse>>;
+
+public record UserProfileResponse(
+    [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+    string Name,
+    string? FirstName,
+    string? SecondName,
+    string? ProfilePictureUrl,
+    DateTime CreatedAt,
+    int FollowersCount,
+    int FollowingCount,
+    bool IsFollowing,
+    bool CanViewFollowers);
+
+public class GetUserProfileQueryHandler(IDatabase database)
+    : IQueryHandler<GetUserProfileQuery, ErrorOr<UserProfileResponse>>
 {
-    public record GetUserProfileQuery(long UserId, long? ViewerId = null) : IQuery<ErrorOr<UserProfileResponse>>;
-
-    public record UserProfileResponse(
-        [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
-        string Name,
-        string? FirstName,
-        string? SecondName,
-        string? ProfilePictureUrl,
-        DateTime CreatedAt,
-        int FollowersCount,
-        int FollowingCount,
-        bool IsFollowing,
-        bool CanViewFollowers);
-
-    public class GetUserProfileQueryHandler(IDatabase database)
-        : IQueryHandler<GetUserProfileQuery, ErrorOr<UserProfileResponse>>
+    public async ValueTask<ErrorOr<UserProfileResponse>> Handle(GetUserProfileQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<UserProfileResponse>> Handle(GetUserProfileQuery request, CancellationToken cancellationToken)
-        {
-            var user = await database.Users
+        var user = await database.Users
+            .AsNoTracking()
+            .Where(u => u.Id == request.UserId)
+            .Select(u => new
+            {
+                u.Id,
+                u.Name,
+                u.FirstName,
+                u.SecondName,
+                u.ProfilePictureUrl,
+                u.CreatedAt
+            })
+            .SingleOrDefaultAsync(cancellationToken);
+
+        if (user == null)
+            return Error.NotFound();
+
+        var followersCount = await database.UserFollows
+            .AsNoTracking()
+            .CountAsync(f => f.FollowedId == request.UserId, cancellationToken);
+
+        var followingCount = await database.UserFollows
+            .AsNoTracking()
+            .CountAsync(f => f.FollowerId == request.UserId, cancellationToken);
+
+        var isFollowing = request.ViewerId is { } viewerId && viewerId != request.UserId &&
+            await database.UserFollows
                 .AsNoTracking()
-                .Where(u => u.Id == request.UserId)
-                .Select(u => new
-                {
-                    u.Id,
-                    u.Name,
-                    u.FirstName,
-                    u.SecondName,
-                    u.ProfilePictureUrl,
-                    u.CreatedAt
-                })
-                .SingleOrDefaultAsync(cancellationToken);
+                .AnyAsync(f => f.FollowerId == viewerId && f.FollowedId == request.UserId, cancellationToken);
 
-            if (user == null)
-                return Error.NotFound();
+        var canViewFollowers = await FollowVisibility.CanViewFollowersAsync(
+            database, request.ViewerId, request.UserId, cancellationToken);
 
-            var followersCount = await database.UserFollows
-                .AsNoTracking()
-                .CountAsync(f => f.FollowedId == request.UserId, cancellationToken);
-
-            var followingCount = await database.UserFollows
-                .AsNoTracking()
-                .CountAsync(f => f.FollowerId == request.UserId, cancellationToken);
-
-            var isFollowing = request.ViewerId is { } viewerId && viewerId != request.UserId &&
-                await database.UserFollows
-                    .AsNoTracking()
-                    .AnyAsync(f => f.FollowerId == viewerId && f.FollowedId == request.UserId, cancellationToken);
-
-            var canViewFollowers = await FollowVisibility.CanViewFollowersAsync(
-                database, request.ViewerId, request.UserId, cancellationToken);
-
-            return new UserProfileResponse(
-                user.Id,
-                user.Name,
-                user.FirstName,
-                user.SecondName,
-                user.ProfilePictureUrl,
-                user.CreatedAt,
-                followersCount,
-                followingCount,
-                isFollowing,
-                canViewFollowers);
-        }
+        return new UserProfileResponse(
+            user.Id,
+            user.Name,
+            user.FirstName,
+            user.SecondName,
+            user.ProfilePictureUrl,
+            user.CreatedAt,
+            followersCount,
+            followingCount,
+            isFollowing,
+            canViewFollowers);
     }
 }

backend/Core/Musify.Application/Users/GetUsers.cs

@@ -1,45 +1,44 @@
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
 using Musify.Application.Shared;
 using Musify.Application.Users.Responses;
 using X.PagedList.EF;
-using Musify.Application.Contracts;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record GetUsersQuery(int PageNumber, int PageSize, string? UsernameSearch, long? ViewerId = null)
+    : IQuery<ErrorOr<PaginatedResponse<UserSummaryResponse>>>;
+
+public class GetUsersQueryHandler(IDatabase database)
+    : IQueryHandler<GetUsersQuery, ErrorOr<PaginatedResponse<UserSummaryResponse>>>
 {
-    public record GetUsersQuery(int PageNumber, int PageSize, string? UsernameSearch, long? ViewerId = null)
-        : IQuery<ErrorOr<PaginatedResponse<UserSummaryResponse>>>;
-
-    public class GetUsersQueryHandler(IDatabase database)
-        : IQueryHandler<GetUsersQuery, ErrorOr<PaginatedResponse<UserSummaryResponse>>>
+    public async ValueTask<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Handle(GetUsersQuery request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<PaginatedResponse<UserSummaryResponse>>> Handle(GetUsersQuery request, CancellationToken cancellationToken)
+        var usersQuery = database.Users
+            .AsNoTracking()
+            .AsQueryable();
+
+        if (!string.IsNullOrEmpty(request.UsernameSearch))
         {
-            var usersQuery = database.Users
-                .AsNoTracking()
-                .AsQueryable();
-
-            if (!string.IsNullOrEmpty(request.UsernameSearch))
-            {
-                var normalizedUsername = request.UsernameSearch.Trim().ToUpperInvariant();
-                usersQuery = usersQuery.Where(u => u.NormalizedName.Contains(normalizedUsername));
-            }
-
-            var totalCount = await usersQuery.CountAsync(cancellationToken);
-            var viewerId = request.ViewerId;
-            var pagedUsers = await usersQuery
-                .OrderBy(u => u.Name)
-                .Select(u => new UserSummaryResponse(
-                    u.Id,
-                    u.Name,
-                    u.FirstName,
-                    u.SecondName,
-                    u.ProfilePictureUrl,
-                    viewerId != null && database.UserFollows.Any(f => f.FollowerId == viewerId && f.FollowedId == u.Id)))
-                .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
-
-            return PaginatedResponse<UserSummaryResponse>.FromPagedList(pagedUsers);
+            var normalizedUsername = request.UsernameSearch.Trim().ToUpperInvariant();
+            usersQuery = usersQuery.Where(u => u.NormalizedName.Contains(normalizedUsername));
         }
+
+        var totalCount = await usersQuery.CountAsync(cancellationToken);
+        var viewerId = request.ViewerId;
+        var pagedUsers = await usersQuery
+            .OrderBy(u => u.Name)
+            .Select(u => new UserSummaryResponse(
+                u.Id,
+                u.Name,
+                u.FirstName,
+                u.SecondName,
+                u.ProfilePictureUrl,
+                viewerId != null && database.UserFollows.Any(f => f.FollowerId == viewerId && f.FollowedId == u.Id)))
+            .ToPagedListAsync(request.PageNumber, request.PageSize, totalCount, cancellationToken);
+
+        return PaginatedResponse<UserSummaryResponse>.FromPagedList(pagedUsers);
     }
 }

backend/Core/Musify.Application/Users/IsFollowingUser.cs

@@ -2,16 +2,15 @@ using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.Users
-{
-    public record IsFollowingUserQuery(long FollowerId, long FollowedId) : IQuery<bool>;
+namespace Musify.Application.Users;
 
-    public class IsFollowingUserQueryHandler(IDatabase database)
-        : IQueryHandler<IsFollowingUserQuery, bool>
-    {
-        public ValueTask<bool> Handle(IsFollowingUserQuery request, CancellationToken cancellationToken) =>
-            new(database.UserFollows
-                .AsNoTracking()
-                .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken));
-    }
+public record IsFollowingUserQuery(long FollowerId, long FollowedId) : IQuery<bool>;
+
+public class IsFollowingUserQueryHandler(IDatabase database)
+    : IQueryHandler<IsFollowingUserQuery, bool>
+{
+    public ValueTask<bool> Handle(IsFollowingUserQuery request, CancellationToken cancellationToken) =>
+        new(database.UserFollows
+            .AsNoTracking()
+            .AnyAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken));
 }

backend/Core/Musify.Application/Users/Responses/UserApplicationResponse.cs

@@ -1,28 +1,27 @@
-using System.Text.Json.Serialization;
+using System.Text.Json.Serialization;
 using Musify.Application.Serialization;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Users.Responses
+namespace Musify.Application.Users.Responses;
+
+public record UserApplicationResponse(
+    [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+    string Name,
+    string? FirstName,
+    string? SecondName,
+    string? ProfilePictureUrl,
+    DateTime CreatedAt,
+    DateTime UpdatedAt)
 {
-    public record UserApplicationResponse(
-        [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
-        string Name,
-        string? FirstName,
-        string? SecondName,
-        string? ProfilePictureUrl,
-        DateTime CreatedAt,
-        DateTime UpdatedAt)
+    public static UserApplicationResponse FromEntity(User user)
     {
-        public static UserApplicationResponse FromEntity(User user)
-        {
-            return new UserApplicationResponse(
-                user.Id,
-                user.Name,
-                user.FirstName,
-                user.SecondName,
-                user.ProfilePictureUrl,
-                user.CreatedAt,
-                user.UpdatedAt);
-        }
+        return new UserApplicationResponse(
+            user.Id,
+            user.Name,
+            user.FirstName,
+            user.SecondName,
+            user.ProfilePictureUrl,
+            user.CreatedAt,
+            user.UpdatedAt);
     }
-}
+}

backend/Core/Musify.Application/Users/Responses/UserSummaryResponse.cs

@@ -1,13 +1,12 @@
 using System.Text.Json.Serialization;
 using Musify.Application.Serialization;
 
-namespace Musify.Application.Users.Responses
-{
-    public record UserSummaryResponse(
-        [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
-        string Name,
-        string? FirstName,
-        string? SecondName,
-        string? ProfilePictureUrl,
-        bool IsFollowedByViewer);
-}
+namespace Musify.Application.Users.Responses;
+
+public record UserSummaryResponse(
+    [property: JsonConverter(typeof(LongAsStringConverter))] long Id,
+    string Name,
+    string? FirstName,
+    string? SecondName,
+    string? ProfilePictureUrl,
+    bool IsFollowedByViewer);

backend/Core/Musify.Application/Users/SyncUser.cs

@@ -5,53 +5,52 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Domain.Entities;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record SyncUserCommand(
+    long Id,
+    string Name,
+    string? FirstName,
+    string? SecondName,
+    string? ProfilePictureUrl)
+    : ICommand<ErrorOr<Success>>;
+
+public class SyncUserCommandHandler(IDatabase database, ILogger<SyncUserCommandHandler> logger)
+    : ICommandHandler<SyncUserCommand, ErrorOr<Success>>
 {
-    public record SyncUserCommand(
-        long Id,
-        string Name,
-        string? FirstName,
-        string? SecondName,
-        string? ProfilePictureUrl)
-        : ICommand<ErrorOr<Success>>;
-
-    public class SyncUserCommandHandler(IDatabase database, ILogger<SyncUserCommandHandler> logger)
-        : ICommandHandler<SyncUserCommand, ErrorOr<Success>>
+    public async ValueTask<ErrorOr<Success>> Handle(SyncUserCommand request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<Success>> Handle(SyncUserCommand request, CancellationToken cancellationToken)
+        var user = await database.Users
+            .SingleOrDefaultAsync(u => u.Id == request.Id, cancellationToken);
+
+        if (user == null)
         {
-            var user = await database.Users
-                .SingleOrDefaultAsync(u => u.Id == request.Id, cancellationToken);
-
-            if (user == null)
+            await database.Users.AddAsync(new User
             {
-                await database.Users.AddAsync(new User
-                {
-                    Id = request.Id,
-                    Name = request.Name,
-                    NormalizedName = request.Name.ToUpperInvariant(),
-                    FirstName = request.FirstName,
-                    SecondName = request.SecondName,
-                    ProfilePictureUrl = request.ProfilePictureUrl
-                }, cancellationToken);
+                Id = request.Id,
+                Name = request.Name,
+                NormalizedName = request.Name.ToUpperInvariant(),
+                FirstName = request.FirstName,
+                SecondName = request.SecondName,
+                ProfilePictureUrl = request.ProfilePictureUrl
+            }, cancellationToken);
 
-                await database.SaveChangesAsync(cancellationToken);
-                logger.LogInformation("Provisioned user {UserId}", request.Id);
-
-                return new Success();
-            }
-
-            user.Name = request.Name;
-            user.NormalizedName = request.Name.ToUpperInvariant();
-            user.FirstName = request.FirstName;
-            user.SecondName = request.SecondName;
-            user.ProfilePictureUrl = request.ProfilePictureUrl;
-
-            var written = await database.SaveChangesAsync(cancellationToken);
-            if (written > 0)
-                logger.LogInformation("Synced profile for user {UserId}", request.Id);
+            await database.SaveChangesAsync(cancellationToken);
+            logger.LogInformation("Provisioned user {UserId}", request.Id);
 
             return new Success();
         }
+
+        user.Name = request.Name;
+        user.NormalizedName = request.Name.ToUpperInvariant();
+        user.FirstName = request.FirstName;
+        user.SecondName = request.SecondName;
+        user.ProfilePictureUrl = request.ProfilePictureUrl;
+
+        var written = await database.SaveChangesAsync(cancellationToken);
+        if (written > 0)
+            logger.LogInformation("Synced profile for user {UserId}", request.Id);
+
+        return new Success();
     }
 }

backend/Core/Musify.Application/Users/UnfollowUser.cs

@@ -4,29 +4,28 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 
-namespace Musify.Application.Users
+namespace Musify.Application.Users;
+
+public record UnfollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
+
+public class UnfollowUserCommandHandler(
+    IDatabase database,
+    ILogger<UnfollowUserCommandHandler> logger)
+    : ICommandHandler<UnfollowUserCommand, ErrorOr<Success>>
 {
-    public record UnfollowUserCommand(long FollowerId, long FollowedId) : ICommand<ErrorOr<Success>>;
-
-    public class UnfollowUserCommandHandler(
-        IDatabase database,
-        ILogger<UnfollowUserCommandHandler> logger)
-        : ICommandHandler<UnfollowUserCommand, ErrorOr<Success>>
+    public async ValueTask<ErrorOr<Success>> Handle(UnfollowUserCommand request, CancellationToken cancellationToken)
     {
-        public async ValueTask<ErrorOr<Success>> Handle(UnfollowUserCommand request, CancellationToken cancellationToken)
-        {
-            var follow = await database.UserFollows
-                .SingleOrDefaultAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
-
-            if (follow == null)
-                return new Success();
-
-            database.UserFollows.Remove(follow);
-            await database.SaveChangesAsync(cancellationToken);
-
-            logger.LogInformation("User {FollowerId} unfollowed user {FollowedId}", request.FollowerId, request.FollowedId);
+        var follow = await database.UserFollows
+            .SingleOrDefaultAsync(f => f.FollowerId == request.FollowerId && f.FollowedId == request.FollowedId, cancellationToken);
 
+        if (follow == null)
             return new Success();
-        }
+
+        database.UserFollows.Remove(follow);
+        await database.SaveChangesAsync(cancellationToken);
+
+        logger.LogInformation("User {FollowerId} unfollowed user {FollowedId}", request.FollowerId, request.FollowedId);
+
+        return new Success();
     }
 }