Code Migrator

## Migration: React Class Components -> Hooks

### Pre-migration
- [ ] Audit: List all class components (found: 47)
- [ ] Categorize by complexity (simple: 30, medium: 12, complex: 5)
- [ ] Write integration tests for components without coverage
- [ ] Set up linting rule to warn on new class components

### Migration waves
- [ ] Wave 1: Simple components (no lifecycle, no state)    [Week 1-2]
- [ ] Wave 2: Stateful components (useState conversion)     [Week 3-4]
- [ ] Wave 3: Lifecycle components (useEffect conversion)   [Week 5-6]
- [ ] Wave 4: Complex components (HOCs, render props)       [Week 7-8]
- [ ] Wave 5: Shared/library components                     [Week 9-10]

### Post-migration
- [ ] Remove class component utilities/base classes
- [ ] Update coding standards documentation
- [ ] Enable lint rule to error on class components
- [ ] Remove React.Component from allowed types

Phase 1: Route traffic through a facade
    Client -> [Facade] -> [Old System]

Phase 2: Implement new component, route some traffic to it
    Client -> [Facade] -> [New Component A]
                       -> [Old System (rest)]

Phase 3: Continue until old system has no traffic
    Client -> [Facade] -> [New Component A]
                       -> [New Component B]
                       -> [New Component C]
                       -> [Old System (empty)]

Phase 4: Remove old system
    Client -> [Facade] -> [New Component A]
                       -> [New Component B]
                       -> [New Component C]

// Facade: proxy routes to old or new handler
app.all('/api/*', (req, res) => {
  const migratedRoutes = ['/api/users', '/api/users/:id'];

  if (migratedRoutes.some(r => req.path.match(routeToRegex(r)))) {
    return fastifyApp.inject({ method: req.method, url: req.url, payload: req.body })
      .then(response => res.status(response.statusCode).send(response.body));
  }

  return oldExpressRouter.handle(req, res);
});

# Step 1: Create abstraction
class UserRepository(Protocol):
    def get_user(self, user_id: str) -> User: ...
    def save_user(self, user: User) -> None: ...

# Step 2: Wrap old implementation
class MySQLUserRepository:
    def get_user(self, user_id: str) -> User:
        # existing MySQL code
        ...

# Step 3: Build new implementation
class PostgresUserRepository:
    def get_user(self, user_id: str) -> User:
        # new PostgreSQL code
        ...

# Step 4: Switch via configuration
def create_user_repository(config) -> UserRepository:
    if config.use_postgres:
        return PostgresUserRepository(config.pg_url)
    return MySQLUserRepository(config.mysql_url)

Day 1:   Enable for internal users only          (1% traffic)
Day 3:   Enable for beta users                    (5% traffic)
Day 7:   Enable for 10% of all users             (10% traffic)
Day 10:  Enable for 50%                           (50% traffic)
Day 14:  Enable for 100%                          (100% traffic)
Day 21:  Remove flag and old code                 (cleanup)

async function getUser(userId: string): Promise<User> {
  if (await featureFlags.isEnabled('use-new-user-service', { userId })) {
    return newUserService.getUser(userId);
  }
  return legacyUserService.getUser(userId);
}

-- Step 1: Expand - add new column
ALTER TABLE users ADD COLUMN full_name VARCHAR(255);

-- Step 3: Backfill
UPDATE users SET full_name = CONCAT(first_name, ' ', last_name) WHERE full_name IS NULL;

-- Step 6: Contract - remove old columns (after code migration complete)
ALTER TABLE users DROP COLUMN first_name;
ALTER TABLE users DROP COLUMN last_name;