claude-swift-engineering

### Feature Implementation: User Profile Management

**Context:** We're building a social media app where users can edit their profile. The feature includes: updating display name, bio, and avatar, with validation and persistence. The TCA implementation will handle state changes, side effects (API calls), and view interactions.

---

#### 1. State Definition
```swift
struct ProfileState: Equatable {
    var displayName: String = ""
    var bio: String = ""
    var avatarData: Data? = nil
    var isLoading = false
    var saveError: String? = nil
    var validationError: String? = nil
}
```

#### 2. Actions
```swift
enum ProfileAction: Equatable {
    case displayNameChanged(String)
    case bioChanged(String)
    case avatarSelected(Data)
    case saveButtonTapped
    case saveResponse(Result<Profile, Error>)
    case cancelButtonTapped
}
```

#### 3. Reducer
```swift
let profileReducer = Reducer<ProfileState, ProfileAction, ProfileEnvironment> { state, action, environment in
    switch action {
    case let .displayNameChanged(newName):
        state.displayName = newName
        state.validationError = nil
        return .none

    case let .bioChanged(newBio):
        state.bio = newBio
        return .none

    case let .avatarSelected(data):
        state.avatarData = data
        return .none

    case .saveButtonTapped:
        state.isLoading = true
        state.saveError = nil
        
        guard !state.displayName.isEmpty else {
            state.validationError = "Display name cannot be empty"
            state.isLoading = false
            return .none
        }
        
        let profile = Profile(
            displayName: state.displayName,
            bio: state.bio,
            avatarData: state.avatarData
        )
        
        return environment.profileService
            .saveProfile(profile)
            .receive(on: environment.mainQueue)
            .catchToEffect(ProfileAction.saveResponse)

    case let .saveResponse(.success(profile)):
        state.isLoading = false
        state.displayName = profile.displayName
        state.bio = profile.bio
        state.avatarData = profile.avatarData
        return .none

    case let .saveResponse(.failure(error)):
        state.isLoading = false
        state.saveError = error.localizedDescription
        return .none

    case .cancelButtonTapped:
        state.validationError = nil
        return .none
    }
}
```

#### 4. Environment
```swift
struct ProfileEnvironment {
    var profileService: ProfileService
    var mainQueue: AnySchedulerOf<DispatchQueue>
}
```

#### 5. SwiftUI View
```swift
struct ProfileView: View {
    let store: Store<ProfileState, ProfileAction>

    var body: some View {
        WithViewStore(store) { viewStore in
            Form {
                Section(header: Text("Profile Information")) {
                    TextField("Display Name", text: viewStore.binding(
                        get: \.displayName,
                        send: ProfileAction.displayNameChanged
                    ))
                    
                    TextEditor(text: viewStore.binding(
                        get: \.bio,
                        send: ProfileAction.bioChanged
                    ))
                    .frame(height: 100)
                    
                    if let error = viewStore.validationError {
                        Text(error)
                            .foregroundColor(.red)
                    }
                }

                Section {
                    Button("Save Profile") {
                        viewStore.send(.saveButtonTapped)
                    }
                    .disabled(viewStore.isLoading)

                    if viewStore.isLoading {
                        ProgressView()
                    }
                }
            }
            .navigationTitle("Edit Profile")
            .onAppear { viewStore.send(.onAppear) }
        }
    }
}
```

#### 6. Unit Tests
```swift
func testProfileReducer_SaveSuccess() {
    let scheduler = DispatchQueue.test
    let environment = ProfileEnvironment(
        profileService: .mock(saveResult: .success(.mock)),
        mainQueue: scheduler.eraseToAnyScheduler()
    )
    
    let store = TestStore(
        initialState: ProfileState(displayName: "Test User"),
        reducer: profileReducer,
        environment: environment
    )

    store.send(.saveButtonTapped) {
        $0.isLoading = true
    }

    scheduler.advance()

    store.receive(.saveResponse(.success(.mock))) {
        $0.isLoading = false
        $0.displayName = "Test User"
    }
}
```

#### 7. Documentation
```markdown
## Profile Feature

### Overview
Manages user profile updates with validation and persistence.

### State
- `displayName`: Current display name
- `bio`: User biography
- `avatarData`: Selected avatar image data
- `isLoading`: Loading state for API calls
- `saveError`: Error message if save fails
- `validationError`: Validation errors for form fields

### Actions
- `displayNameChanged`: Updates display name
- `bioChanged`: Updates biography
- `avatarSelected`: Handles avatar image selection
- `saveButtonTapped`: Initiates save operation
- `saveResponse`: Handles API response
- `cancelButtonTapped`: Resets form state

### Environment
- `profileService`: Handles API calls
- `mainQueue`: Scheduler for UI updates
```

#### 8. GitHub Actions Workflow
```yaml
name: Profile Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run tests
        run: swift test --filter ProfileFeatureTests
```