Code Duplication Detection

We audited an Express Login demo to identify duplicated code patterns and suggest practical refactors. This lesson digs deeper into exact duplicates, near-duplicates, structural repetition, and repeated data/constants — and gives concrete code you can drop into the repo to reduce duplication and centralize behavior.

The audit begins by prompting Claude Code for Beginners to scan the repository and produce a structured report. Example of the interactive prompt and initial output:

* Welcome to Claude Code!

/help for help, /status for your current setup

cwd: /Users/jeremy/Repos/Claude Code Course/Express-login-demo

> [Pasted text #1 +47 lines]

Claude enumerates files and reads content:

• Read(config/database.js)
└ Read 19 lines (ctrl+r to expand)

• Read(package.json)
└ Read 25 lines (ctrl+r to expand)

• Read(schema.sql)
└ Read 22 lines (ctrl+r to expand)

• List(~/Repos/Claude Code Course/Express-login-demo)
└ Listed 32 paths (ctrl+r to expand)

• Read(examples.md)
└ Read 3 lines (ctrl+r to expand)

• Write(audits/CODE_DUPLICATION_ANALYSIS.md)
└ Wrote 276 lines to audits/CODE_DUPLICATION_ANALYSIS.md

Below is a cleaned, consolidated Code Duplication Analysis Report with key findings, recommended remediation, and copy-paste-ready code examples to centralize shared logic and configuration.

Executive summary

This analysis targets duplication across the small Express.js app. Overall the codebase follows DRY principles, but several low- to medium-effort improvements will pay off as the project grows:

Centralize environment-derived configuration (high priority)
Consolidate error response formatting (medium)
Abstract database error mapping/handling (medium)
Extract constants for consistency (low)

Estimated refactor time: ~3–4 hours.

Scope & methodology

Files inspected:

server.js
routes/auth.js
config/database.js
package.json
schema.sql
Additional small files in the repo

Approach:

Identify exact and near-duplicates
Look for repeated data (env variables, constants)
Propose utility modules and constants to centralize logic

Findings at a glance

Duplication Type	Severity	Location	Example Pattern	Recommended Remediation	Effort
Exact duplicates	1/10	—	No exact file copies	N/A — keep monitoring	Very low
Near duplicates	3/10	`routes/auth.js`	Repeated `res.status(...).json({ error: '...' })`	`utils/createErrorResponse`	Low (~30 min)
DB error handling duplicates	3/10	`routes/auth.js`	Repeated switch/if handling DB error codes	`utils/handleDatabaseError` + `DB_ERROR_MAP`	Medium (~1 hr)
Structural duplicates	2/10	Routers/DB connections	Repeated router or connection boilerplate	Router factory / connection factory (future)	Low–Medium
Data duplication (env)	4/10	Scattered across files	`process.env.*` repeated	`config/index.js` central config	Low–Medium (~45 min)

Detailed findings & remediation

1) Exact duplicates

Severity: 1/10 — none found. Great.

2) Near duplicates — repeated error responses

Location: routes/auth.js (multiple endpoints) Common duplicated pattern:

// Pattern repeated multiple times with small variations
return res.status(STATUS_CODE).json({
  error: 'MESSAGE'
});

Remediation: centralize error responses in a small utility so all routes return the same structure and can optionally include details. Suggested implementation:

// utils/index.js
function createErrorResponse(res, statusCode, message, details = null) {
  const response = { error: message };
  if (details) response.details = details;
  return res.status(statusCode).json(response);
}

// Usage in a route
createErrorResponse(res, 401, 'Invalid credentials');
createErrorResponse(res, 400, 'Validation failed', errors.array());

Effort: Low (≈30 minutes)

3) Database error handling pattern

Location: routes/auth.js (error handlers after DB calls) Pattern: repeated switch/case or if/else blocks mapping DB error codes to responses. Remediation: create a DB error map and a handler function that delegates to createErrorResponse. Example:

// utils/index.js (excerpt)
const DB_ERROR_MAP = {
  'ECONNREFUSED': { status: 503, message: 'Database connection failed' },
  '28P01': { status: 503, message: 'Database authentication failed' },
  '3D000': { status: 503, message: 'Database does not exist' }
};

function handleDatabaseError(error, res) {
  const errorInfo = DB_ERROR_MAP[error.code];
  if (errorInfo) {
    return createErrorResponse(res, errorInfo.status, errorInfo.message);
  }
  return createErrorResponse(res, 500, 'Database error occurred');
}

Effort: Medium (≈1 hour). Extensible: add additional DB vendor codes or map SQLState codes for more granularity.

4) Structural duplicates

Severity: 2/10 — router and connection setup patterns are repeated but consistent. Remediation: when the codebase grows, consider:

Router factory functions to reduce boilerplate across many routes.
Database connection factory to manage multiple connection pools.

5) Data duplication — environment variables and config values

Severity: 4/10 — process.env.* scattered in multiple files. Remediation: centralize env and derived configuration into config/index.js. This makes it easy to add validation (e.g., using envalid or joi) and to mock in tests. Suggested file:

// config/index.js
module.exports = {
  server: {
    port: process.env.PORT || 3000
  },
  database: {
    host: process.env.DB_HOST,
    port: process.env.DB_PORT,
    name: process.env.DB_NAME,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD
  },
  jwt: {
    secret: process.env.JWT_SECRET,
    expiresIn: process.env.JWT_EXPIRES_IN || '24h'
  }
};

Effort: Low–Medium (≈45 minutes)

Recommended utilities and constants

Add the following core files to centralize behavior and make refactors low-risk.

utils/index.js — central error and validation handlers

// utils/index.js
const { HTTP_STATUS } = require('../constants'); // adjust path as needed

function createErrorResponse(res, statusCode, message, details = null) {
  const response = { error: message };
  if (details) response.details = details;
  return res.status(statusCode).json(response);
}

const DB_ERROR_MAP = {
  'ECONNREFUSED': { status: HTTP_STATUS.SERVICE_UNAVAILABLE, message: 'Database connection failed' },
  '28P01': { status: HTTP_STATUS.SERVICE_UNAVAILABLE, message: 'Database authentication failed' },
  '3D000': { status: HTTP_STATUS.SERVICE_UNAVAILABLE, message: 'Database does not exist' }
};

function handleDatabaseError(error, res) {
  const errorInfo = DB_ERROR_MAP[error.code];
  if (errorInfo) {
    return createErrorResponse(res, errorInfo.status, errorInfo.message);
  }
  return createErrorResponse(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, 'Database error occurred');
}

function handleValidationErrors(errors, res) {
  if (!errors.isEmpty()) {
    return createErrorResponse(res, HTTP_STATUS.BAD_REQUEST, 'Validation failed', errors.array());
  }
  return null;
}

module.exports = {
  createErrorResponse,
  handleDatabaseError,
  handleValidationErrors
};

constants/index.js — central constants

// constants/index.js
const HTTP_STATUS = {
  OK: 200,
  BAD_REQUEST: 400,
  UNAUTHORIZED: 401,
  FORBIDDEN: 403,
  NOT_FOUND: 404,
  INTERNAL_SERVER_ERROR: 500,
  SERVICE_UNAVAILABLE: 503
};

module.exports = {
  HTTP_STATUS
};

config/index.js — central configuration (already shown above)

Implementation priority

Priority	Item	Rationale
High	Centralize environment variables → `config/index.js`	Prevents env spread, simplifies testing and secrets management
Medium	Create error response utilities → `utils/index.js`	Unifies response format and reduces repetitive code
Medium	Create DB error handler + map → `utils/index.js`	Centralizes DB error-to-response mapping
Low	Extract constants → `constants/index.js`	Improves consistency and avoids magic numbers

Summary & estimates

Overall Duplication Score: 2.5/10 — Very Low
Total Estimated Refactoring Effort: ~3–4 hours
Files to update: routes/auth.js, config/database.js, server.js
New files: utils/index.js, constants/index.js, config/index.js

These changes will make the codebase easier to maintain, reduce future duplication, and provide consistent behavior across routes and error handling.

Centralizing configuration and error handling reduces future duplication and makes updates (like changing response formats or adding DB error mappings) quick and low-risk.

Do not commit secrets to source control. Keep JWT_SECRET, DB passwords, and other sensitive values in environment variables, a secrets manager, or secure CI/CD variables.

After addressing duplication, focus on consistent naming conventions and readability — these help humans (and AI tools) reason about and maintain the code. Links and references

Introduction

Getting Started with Claude Code

Working with Claude Code

Code Review with Claude Code

Security Auditing with Claude Code

Advanced Features

Code Duplication Detection

Executive summary

Scope & methodology

Findings at a glance

Detailed findings & remediation

1) Exact duplicates

2) Near duplicates — repeated error responses

3) Database error handling pattern

4) Structural duplicates

5) Data duplication — environment variables and config values

Recommended utilities and constants

Implementation priority

Summary & estimates

Watch Video

​Executive summary

​Scope & methodology

​Findings at a glance

​Detailed findings & remediation

​1) Exact duplicates

​2) Near duplicates — repeated error responses

​3) Database error handling pattern

​4) Structural duplicates

​5) Data duplication — environment variables and config values

​Recommended utilities and constants

​Implementation priority

​Summary & estimates

Watch Video

Executive summary

Scope & methodology

Findings at a glance

Detailed findings & remediation

1) Exact duplicates

2) Near duplicates — repeated error responses

3) Database error handling pattern

4) Structural duplicates

5) Data duplication — environment variables and config values

Recommended utilities and constants

Implementation priority

Summary & estimates