Demo SOLID Principles Evaluation

cwd: /Users/jeremy/Repos/[Claude Code For Beginners](https://learn.kodekloud.com/user/courses/claude-code-for-beginners)/Express-login-demo

What's new:
• Fixed issue causing "OAuth authentication is currently not supported"
• Status line input now includes `exceeds_200k_tokens`
• Fixed incorrect usage tracking in /cost.
• Introduced `ANTHROPIC_DEFAULT_SONNET_MODEL` and `ANTHROPIC_DEFAULT_OPUS_MODEL` for controlling model aliases opusplan, opus, and sonnet.
• Bedrock: Updated default Sonnet model to Sonnet 4

> [Pasted text #1 +47 lines]

// routes/auth.js (simplified)
router.post('/login', async (req, res) => {
  // 1. Validate req.body
  // 2. Query database for user
  // 3. Compare password with bcrypt
  // 4. Generate JWT
  // 5. Handle and map errors to responses
  // ... ~79 lines of mixed concerns
});

// repositories/userRepository.js
class UserRepository {
  constructor(pool) { this.pool = pool; }
  async findByEmail(email) {
    const result = await this.pool.query('SELECT * FROM users WHERE email = $1', [email]);
    return result.rows[0];
  }
}
module.exports = UserRepository;

// services/authService.js
const bcrypt = require('bcrypt');
class AuthService {
  constructor(userRepository, jwtService) {
    this.userRepository = userRepository;
    this.jwtService = jwtService;
  }
  async login(email, password) {
    const user = await this.userRepository.findByEmail(email);
    if (!user) throw new Error('InvalidCredentials');
    const match = await bcrypt.compare(password, user.password_hash);
    if (!match) throw new Error('InvalidCredentials');
    return this.jwtService.generateToken({ id: user.id, email: user.email });
  }
}
module.exports = AuthService;

// routes/auth.js (controller)
const authController = (authService) => ({
  async login(req, res) {
    try {
      const token = await authService.login(req.body.email, req.body.password);
      res.json({ token });
    } catch (err) {
      // map domain errors to http responses
      res.status(401).json({ error: err.message });
    }
  }
});

// Anti-pattern
switch (error.code) {
  case 'ECONNREFUSED':
    return res.status(503).json({ error: 'Database connection failed' });
  case '28P01':
    return res.status(503).json({ error: 'Database authentication failed' });
  // every new error code needs modifying this switch
}

// errorMapping.js
const errorMap = {
  ECONNREFUSED: { status: 503, body: { error: 'Database connection failed' } },
  '28P01': { status: 503, body: { error: 'Database authentication failed' } },
};

function mapDbError(err) {
  return errorMap[err.code] || { status: 500, body: { error: 'Internal Server Error' } };
}
module.exports = { mapDbError };

// Usage in route/service
const { mapDbError } = require('./errorMapping');
const { status, body } = mapDbError(err);
res.status(status).json(body);

// adapters/databaseAdapter.js
class DatabaseAdapter {
  async query(text, params) { throw new Error('Must implement query'); }
}
module.exports = DatabaseAdapter;

// adapters/postgresAdapter.js
const { Pool } = require('pg');
const DatabaseAdapter = require('./databaseAdapter');

class PostgresAdapter extends DatabaseAdapter {
  constructor(config) {
    super();
    this.pool = new Pool(config);
  }
  async query(text, params) {
    return this.pool.query(text, params);
  }
}
module.exports = PostgresAdapter;

// route handler tied to full req/res
router.post('/login', (req, res) => {
  // uses req.body.email, req.body.password, and res.send/json/status
});

// controllers/loginController.js
const loginHandler = async ({ email, password }, responseHandler) => {
  try {
    const token = await authService.login(email, password);
    responseHandler.success({ token });
  } catch (err) {
    responseHandler.error(401, { error: err.message });
  }
};

// wiring in routes
router.post('/login', (req, res) => {
  const credentials = { email: req.body.email, password: req.body.password };
  const responseHandler = {
    success: (data) => res.json(data),
    error: (status, body) => res.status(status).json(body),
  };
  loginHandler(credentials, responseHandler);
});

// repositories/userRepository.js (interface-like)
class UserRepository {
  async findByEmail(email) { throw new Error('Not implemented'); }
}
module.exports = UserRepository;

// repositories/postgresUserRepository.js
const UserRepository = require('./userRepository');
class PostgresUserRepository extends UserRepository {
  constructor(dbAdapter) { super(); this.db = dbAdapter; }
  async findByEmail(email) {
    const result = await this.db.query('SELECT * FROM users WHERE email = $1', [email]);
    return result.rows[0];
  }
}
module.exports = PostgresUserRepository;

// services/jwtService.js
class JwtService {
  constructor(config) { this.config = config; }
  generateToken(payload) {
    const jwt = require('jsonwebtoken'); // JwtService is the seam for mocking
    return jwt.sign(payload, this.config.jwtSecret, { expiresIn: this.config.jwtExpiresIn });
  }
}
module.exports = JwtService;

// Application wiring (bootstrap)
const config = { jwtSecret: process.env.JWT_SECRET, jwtExpiresIn: process.env.JWT_EXPIRES_IN || '24h' };
const dbAdapter = new PostgresAdapter(pgConfig);
const userRepository = new PostgresUserRepository(dbAdapter);
const jwtService = new JwtService(config);
const authService = new AuthService(userRepository, jwtService);

// services/configService.js
class ConfigService {
  get jwtSecret() { return process.env.JWT_SECRET; }
  get jwtExpiresIn() { return process.env.JWT_EXPIRES_IN || '24h'; }
}
module.exports = new ConfigService();

├── services/
│   ├── authService.js
│   ├── jwtService.js
│   └── configService.js
├── repositories/
│   └── userRepository.js
├── adapters/
│   └── postgresAdapter.js
├── strategies/
│   └── authStrategies.js
├── middleware/
│   ├── validation.js
│   └── errorHandler.js