csharpier format all

Author: aligneddev

.specify/memory/constitution.md

@@ -47,7 +47,7 @@ Domain logic isolated from infrastructure concerns via layered architecture alig
 
 ### II. Functional Programming (Pure & Impure Sandwich)
 
-Core calculations and business logic implemented as pure functions: distance-to-distance conversions, expense-to-savings transformations, weather-to-recommendation mappings. Pure functions have no side effects—given the same input, always return the same output. Impure edges (database reads/writes, external API calls, user input, system time) explicitly isolated at application boundaries. Handlers orchestrate pure logic within impure I/O boundaries. **F# discriminated unions and active patterns preferred for domain modeling** (domain layer uses F#); Railway Oriented Programming (Result<'T> type) for error handling; C# records used in API surface for interop.
+Core calculations and business logic implemented as pure functions: distance-to-distance conversions, expense-to-savings transformations, weather-to-recommendation mappings. Pure functions have no side effects—given the same input, always return the same output. Use immutable data structures. Impure edges (database reads/writes, external API calls, user input, system time) explicitly isolated at application boundaries. Handlers orchestrate pure logic within impure I/O boundaries. **F# discriminated unions and active patterns preferred for domain modeling** (domain layer uses F#); Railway Oriented Programming (Result<'T> type) for error handling; C# records used in API surface for interop.
 
 **Rationale**: Pure functions are trivially testable, deterministic, and composable. Side effect isolation makes dataflow explicit and reduces debugging complexity. Immutable data structures preferred where practical. F# enforces immutability and pattern matching, reducing entire categories of bugs. Discriminated unions make invalid states unrepresentable.
 
@@ -168,10 +168,14 @@ Example: "User records a bike ride" slice includes:
 - Background function listening to CES to update RideProjection
 - Aspire AppHost configuration for frontend + API + database orchestration; Azure CLI deployment scripts for Static Web Apps (frontend) and Container Apps (API)
 
-run `dotnet format .` to enforce code style; `dotnet test` to run tests; `dotnet run --project src/BikeTracking.AppHost` to start local stack; GitHub Actions for CI/CD to Azure.
+run `csharpier format .` to enforce code formatting (document in readme.md, `dotnet tool install csharpier -g` is needed); run `dotnet format .` (built-in .NET tool) uses .editorconfig for formatting rules and supports more granular control (e.g., namespace matching, file-scoped namespaces). 
 
+Best Practice: Use CSharpier for consistent formatting and dotnet format for linting and code style enforcement (e.g., dotnet_diagnostic.IDE0130.severity=error in .editorconfig).
 run Typescript linting and formatting via `npm run lint` and `npm run format` in the frontend directory.
 
+Test` to run tests; `dotnet run --project src/BikeTracking.AppHost` to start local stack; GitHub Actions for CI/CD to Azure.
+
+
 ### Vertical Slice Implementation Strategy: Minimal-First Approach
 
 After the application structure is built, implementation proceeds in **vertical slices with minimal functionality first**:

README.md

@@ -22,6 +22,15 @@ Local-first Bike Tracking application built with .NET Aspire orchestration, .NET
 
 - .NET SDK 10.x
 - Node.js 20+ and npm
+- CSharpier global tool (required for formatting checks):
+
+```powershell
+dotnet tool install csharpier -g
+```
+
+run it with `dotnet csharpier format .` from the repo root to format all C# code.
+
+- Helpful editor integration: VS Code CSharpier extension (`csharpier.csharpier-vscode`)
 
 ## Quick Start
 

src/BikeTracking.Api/Application/Events/EfOutboxStore.cs

@@ -5,39 +5,57 @@ namespace BikeTracking.Api.Application.Events;
 
 public sealed class EfOutboxStore(IServiceScopeFactory scopeFactory) : IOutboxStore
 {
-    public async Task<IReadOnlyList<OutboxEventEntity>> LoadPendingAsync(int maxBatchSize, DateTime utcNow, CancellationToken cancellationToken)
+    public async Task<IReadOnlyList<OutboxEventEntity>> LoadPendingAsync(
+        int maxBatchSize,
+        DateTime utcNow,
+        CancellationToken cancellationToken
+    )
     {
         using var scope = scopeFactory.CreateScope();
         var dbContext = scope.ServiceProvider.GetRequiredService<BikeTrackingDbContext>();
 
-        return await dbContext.OutboxEvents
-            .Where(x => x.PublishedAtUtc == null && x.NextAttemptUtc <= utcNow)
+        return await dbContext
+            .OutboxEvents.Where(x => x.PublishedAtUtc == null && x.NextAttemptUtc <= utcNow)
             .OrderBy(x => x.OutboxEventId)
             .Take(maxBatchSize)
             .AsNoTracking()
             .ToListAsync(cancellationToken);
     }
 
-    public async Task MarkPublishedAsync(long outboxEventId, DateTime publishedAtUtc, CancellationToken cancellationToken)
+    public async Task MarkPublishedAsync(
+        long outboxEventId,
+        DateTime publishedAtUtc,
+        CancellationToken cancellationToken
+    )
     {
         using var scope = scopeFactory.CreateScope();
         var dbContext = scope.ServiceProvider.GetRequiredService<BikeTrackingDbContext>();
 
-        var eventEntity = await dbContext.OutboxEvents
-            .SingleAsync(x => x.OutboxEventId == outboxEventId, cancellationToken);
+        var eventEntity = await dbContext.OutboxEvents.SingleAsync(
+            x => x.OutboxEventId == outboxEventId,
+            cancellationToken
+        );
 
         eventEntity.PublishedAtUtc = publishedAtUtc;
         eventEntity.LastError = null;
         await dbContext.SaveChangesAsync(cancellationToken);
     }
 
-    public async Task ScheduleRetryAsync(long outboxEventId, int retryCount, DateTime nextAttemptUtc, string? lastError, CancellationToken cancellationToken)
+    public async Task ScheduleRetryAsync(
+        long outboxEventId,
+        int retryCount,
+        DateTime nextAttemptUtc,
+        string? lastError,
+        CancellationToken cancellationToken
+    )
     {
         using var scope = scopeFactory.CreateScope();
         var dbContext = scope.ServiceProvider.GetRequiredService<BikeTrackingDbContext>();
 
-        var eventEntity = await dbContext.OutboxEvents
-            .SingleAsync(x => x.OutboxEventId == outboxEventId, cancellationToken);
+        var eventEntity = await dbContext.OutboxEvents.SingleAsync(
+            x => x.OutboxEventId == outboxEventId,
+            cancellationToken
+        );
 
         eventEntity.RetryCount = retryCount;
         eventEntity.NextAttemptUtc = nextAttemptUtc;

src/BikeTracking.Api/Application/Events/IOutboxStore.cs

@@ -4,7 +4,21 @@ namespace BikeTracking.Api.Application.Events;
 
 public interface IOutboxStore
 {
-    Task<IReadOnlyList<OutboxEventEntity>> LoadPendingAsync(int maxBatchSize, DateTime utcNow, CancellationToken cancellationToken);
-    Task MarkPublishedAsync(long outboxEventId, DateTime publishedAtUtc, CancellationToken cancellationToken);
-    Task ScheduleRetryAsync(long outboxEventId, int retryCount, DateTime nextAttemptUtc, string? lastError, CancellationToken cancellationToken);
+    Task<IReadOnlyList<OutboxEventEntity>> LoadPendingAsync(
+        int maxBatchSize,
+        DateTime utcNow,
+        CancellationToken cancellationToken
+    );
+    Task MarkPublishedAsync(
+        long outboxEventId,
+        DateTime publishedAtUtc,
+        CancellationToken cancellationToken
+    );
+    Task ScheduleRetryAsync(
+        long outboxEventId,
+        int retryCount,
+        DateTime nextAttemptUtc,
+        string? lastError,
+        CancellationToken cancellationToken
+    );
 }

src/BikeTracking.Api/Application/Events/OutboxPublisherService.cs

@@ -9,7 +9,8 @@ public sealed class OutboxPublisherService(
     IOutboxStore outboxStore,
     IUserRegisteredPublisher userRegisteredPublisher,
     IOptions<IdentityOptions> identityOptions,
-    ILogger<OutboxPublisherService> logger) : BackgroundService
+    ILogger<OutboxPublisherService> logger
+) : BackgroundService
 {
     private readonly OutboxOptions _outboxOptions = identityOptions.Value.Outbox;
 
@@ -45,20 +46,38 @@ private async Task PublishPendingBatchAsync(CancellationToken cancellationToken)
         {
             try
             {
-                if (!string.Equals(outboxEvent.EventType, UserRegisteredEventPayload.EventTypeName, StringComparison.Ordinal))
+                if (
+                    !string.Equals(
+                        outboxEvent.EventType,
+                        UserRegisteredEventPayload.EventTypeName,
+                        StringComparison.Ordinal
+                    )
+                )
                 {
-                    await outboxStore.MarkPublishedAsync(outboxEvent.OutboxEventId, DateTime.UtcNow, cancellationToken);
+                    await outboxStore.MarkPublishedAsync(
+                        outboxEvent.OutboxEventId,
+                        DateTime.UtcNow,
+                        cancellationToken
+                    );
                     continue;
                 }
 
-                var payload = JsonSerializer.Deserialize<UserRegisteredEventPayload>(outboxEvent.EventPayloadJson);
+                var payload = JsonSerializer.Deserialize<UserRegisteredEventPayload>(
+                    outboxEvent.EventPayloadJson
+                );
                 if (payload is null)
                 {
-                    throw new InvalidOperationException($"Unable to deserialize payload for outbox event {outboxEvent.OutboxEventId}.");
+                    throw new InvalidOperationException(
+                        $"Unable to deserialize payload for outbox event {outboxEvent.OutboxEventId}."
+                    );
                 }
 
                 await userRegisteredPublisher.PublishAsync(payload, cancellationToken);
-                await outboxStore.MarkPublishedAsync(outboxEvent.OutboxEventId, DateTime.UtcNow, cancellationToken);
+                await outboxStore.MarkPublishedAsync(
+                    outboxEvent.OutboxEventId,
+                    DateTime.UtcNow,
+                    cancellationToken
+                );
             }
             catch (Exception ex)
             {
@@ -71,14 +90,16 @@ await outboxStore.ScheduleRetryAsync(
                     retryCount,
                     nextAttemptUtc,
                     ex.Message,
-                    cancellationToken);
+                    cancellationToken
+                );
 
                 logger.LogWarning(
                     ex,
                     "Failed to publish outbox event {OutboxEventId}. Retrying at {NextAttemptUtc} (retry #{RetryCount}).",
                     outboxEvent.OutboxEventId,
                     nextAttemptUtc,
-                    retryCount);
+                    retryCount
+                );
             }
         }
     }

src/BikeTracking.Api/Application/Events/UserRegisteredPublisher.cs

@@ -14,27 +14,36 @@ public sealed class UserRegisteredPublisher : IUserRegisteredPublisher
     private readonly ILogger<UserRegisteredPublisher> _logger;
     private int _remainingForcedFailures;
 
-    public UserRegisteredPublisher(IOptions<IdentityOptions> options, ILogger<UserRegisteredPublisher> logger)
+    public UserRegisteredPublisher(
+        IOptions<IdentityOptions> options,
+        ILogger<UserRegisteredPublisher> logger
+    )
     {
         _logger = logger;
         _remainingForcedFailures = Math.Max(0, options.Value.Outbox.FailFirstPublishAttempts);
     }
 
-    public Task PublishAsync(UserRegisteredEventPayload payload, CancellationToken cancellationToken)
+    public Task PublishAsync(
+        UserRegisteredEventPayload payload,
+        CancellationToken cancellationToken
+    )
     {
         cancellationToken.ThrowIfCancellationRequested();
 
         if (_remainingForcedFailures > 0)
         {
             Interlocked.Decrement(ref _remainingForcedFailures);
-            throw new InvalidOperationException("Simulated publish failure for resilience verification.");
+            throw new InvalidOperationException(
+                "Simulated publish failure for resilience verification."
+            );
         }
 
         _logger.LogInformation(
             "Published UserRegistered event. EventId: {EventId}, UserId: {UserId}, UserName: {UserName}",
             payload.EventId,
             payload.UserId,
-            payload.UserName);
+            payload.UserName
+        );
 
         return Task.CompletedTask;
     }

src/BikeTracking.Api/Application/Users/IdentifyService.cs

@@ -10,11 +10,15 @@ public sealed class IdentifyService(
     BikeTrackingDbContext dbContext,
     PinPolicyValidator pinPolicyValidator,
     IPinHasher pinHasher,
-    IOptions<IdentityOptions> identityOptions)
+    IOptions<IdentityOptions> identityOptions
+)
 {
     private readonly ThrottleOptions _throttleOptions = identityOptions.Value.Throttle;
 
-    public async Task<IdentifyResult> IdentifyAsync(IdentifyRequest request, CancellationToken cancellationToken)
+    public async Task<IdentifyResult> IdentifyAsync(
+        IdentifyRequest request,
+        CancellationToken cancellationToken
+    )
     {
         var validationErrors = ValidateRequest(request);
         if (validationErrors.Count > 0)
@@ -24,8 +28,8 @@ public async Task<IdentifyResult> IdentifyAsync(IdentifyRequest request, Cancell
 
         var normalizedName = UserNameNormalizer.Normalize(request.Name);
 
-        var user = await dbContext.Users
-            .Include(x => x.Credential)
+        var user = await dbContext
+            .Users.Include(x => x.Credential)
             .Include(x => x.AuthAttemptState)
             .SingleOrDefaultAsync(x => x.NormalizedName == normalizedName, cancellationToken);
 
@@ -51,15 +55,19 @@ public async Task<IdentifyResult> IdentifyAsync(IdentifyRequest request, Cancell
 
         if (attemptState.DelayUntilUtc is not null && attemptState.DelayUntilUtc > now)
         {
-            var retryAfterSeconds = Math.Max(1, (int)Math.Ceiling((attemptState.DelayUntilUtc.Value - now).TotalSeconds));
+            var retryAfterSeconds = Math.Max(
+                1,
+                (int)Math.Ceiling((attemptState.DelayUntilUtc.Value - now).TotalSeconds)
+            );
             return IdentifyResult.Throttled(retryAfterSeconds);
         }
 
         var pinMatches = pinHasher.Verify(
             request.Pin,
             user.Credential.PinSalt,
             user.Credential.PinHash,
-            user.Credential.IterationCount);
+            user.Credential.IterationCount
+        );
 
         if (pinMatches)
         {
@@ -68,7 +76,9 @@ public async Task<IdentifyResult> IdentifyAsync(IdentifyRequest request, Cancell
             attemptState.DelayUntilUtc = null;
             await dbContext.SaveChangesAsync(cancellationToken);
 
-            return IdentifyResult.Success(new IdentifySuccessResponse(user.UserId, user.DisplayName, true));
+            return IdentifyResult.Success(
+                new IdentifySuccessResponse(user.UserId, user.DisplayName, true)
+            );
         }
 
         attemptState.ConsecutiveWrongCount += 1;
@@ -112,7 +122,8 @@ public sealed record IdentifyResult(
     IdentifyResultType ResultType,
     IdentifySuccessResponse? Response,
     ErrorResponse? Error,
-    int RetryAfterSeconds = 0)
+    int RetryAfterSeconds = 0
+)
 {
     public static IdentifyResult Success(IdentifySuccessResponse response)
     {
@@ -124,15 +135,17 @@ public static IdentifyResult ValidationFailure(IReadOnlyList<string> errors)
         return new IdentifyResult(
             IdentifyResultType.ValidationFailed,
             null,
-            new ErrorResponse(UsersErrorCodes.ValidationFailed, "Validation failed.", errors));
+            new ErrorResponse(UsersErrorCodes.ValidationFailed, "Validation failed.", errors)
+        );
     }
 
     public static IdentifyResult Unauthorized()
     {
         return new IdentifyResult(
             IdentifyResultType.Unauthorized,
             null,
-            new ErrorResponse(UsersErrorCodes.InvalidCredentials, "Invalid name or PIN."));
+            new ErrorResponse(UsersErrorCodes.InvalidCredentials, "Invalid name or PIN.")
+        );
     }
 
     public static IdentifyResult Throttled(int retryAfterSeconds)
@@ -141,7 +154,8 @@ public static IdentifyResult Throttled(int retryAfterSeconds)
             IdentifyResultType.Throttled,
             null,
             new ErrorResponse(UsersErrorCodes.Throttled, "Too many attempts. Try again later."),
-            retryAfterSeconds);
+            retryAfterSeconds
+        );
     }
 }
 

src/BikeTracking.Api/Application/Users/PinPolicyValidator.cs

@@ -18,7 +18,9 @@ public IReadOnlyList<string> Validate(string? pin)
 
         if (pin.Length < _pinPolicy.MinLength || pin.Length > _pinPolicy.MaxLength)
         {
-            errors.Add($"PIN must be between {_pinPolicy.MinLength} and {_pinPolicy.MaxLength} characters.");
+            errors.Add(
+                $"PIN must be between {_pinPolicy.MinLength} and {_pinPolicy.MaxLength} characters."
+            );
         }
 
         if (_pinPolicy.NumericOnly && pin.Any(ch => !char.IsDigit(ch)))