I Stopped Using GitHub Copilot 2026 and My Code Quality Went Up 30%: Here's Why

// Rate limiter implementation using Redis and TypeScript
// Dependencies: ioredis (https://github.com/luin/ioredis), express 4.18+
import { Redis } from 'ioredis';
import { Request, Response, NextFunction } from 'express';

// Configuration interface for rate limiter
interface RateLimiterConfig {
  windowMs: number; // Time window in milliseconds
  maxRequests: number; // Max requests per window per IP
  redisClient: Redis; // Pre-initialized Redis client
  keyPrefix?: string; // Optional prefix for Redis keys
}

// Custom error class for rate limit exceeded
class RateLimitExceededError extends Error {
  constructor(public readonly retryAfterMs: number) {
    super(`Rate limit exceeded. Retry after ${retryAfterMs}ms`);
    this.name = 'RateLimitExceededError';
  }
}

// Custom error class for Redis connection failures
class RateLimiterRedisError extends Error {
  constructor(message: string) {
    super(`Rate limiter Redis error: ${message}`);
    this.name = 'RateLimiterRedisError';
  }
}

/**
 * Creates a rate limiter middleware for Express applications
 * @param config - Rate limiter configuration object
 * @returns Express middleware function
 */
export function createRateLimiter(config: RateLimiterConfig) {
  const {
    windowMs,
    maxRequests,
    redisClient,
    keyPrefix = 'rate_limit:',
  } = config;

  // Validate configuration on initialization
  if (windowMs <= 0) throw new Error('windowMs must be a positive number');
  if (maxRequests <= 0) throw new Error('maxRequests must be a positive number');

  return async function rateLimiterMiddleware(
    req: Request,
    res: Response,
    next: NextFunction
  ) {
    const clientIp = req.headers['x-forwarded-for']?.toString() || req.ip || 'unknown';
    const redisKey = `${keyPrefix}${clientIp}`;

    try {
      // Check if Redis is connected
      if (redisClient.status !== 'ready') {
        throw new RateLimiterRedisError('Redis client not in ready state');
      }

      // Get current request count from Redis
      const currentCount = await redisClient.get(redisKey);
      const count = currentCount ? parseInt(currentCount, 10) : 0;

      if (count >= maxRequests) {
        // Calculate retry time
        const ttl = await redisClient.pttl(redisKey);
        const retryAfter = ttl > 0 ? ttl : windowMs;
        res.setHeader('Retry-After', Math.ceil(retryAfter / 1000));
        return next(new RateLimitExceededError(retryAfter));
      }

      // Increment count and set expiry if first request
      const pipeline = redisClient.pipeline();
      pipeline.incr(redisKey);
      if (!currentCount) pipeline.pexpire(redisKey, windowMs);
      await pipeline.exec();

      // Set rate limit headers
      res.setHeader('X-RateLimit-Limit', maxRequests);
      res.setHeader('X-RateLimit-Remaining', Math.max(0, maxRequests - (count + 1)));
      res.setHeader('X-RateLimit-Reset', new Date(Date.now() + windowMs).toISOString());

      next();
    } catch (error) {
      // Log error but don't block requests if Redis fails (fail open)
      console.error('Rate limiter error:', error);
      if (error instanceof RateLimitExceededError) {
        return res.status(429).json({
          error: error.message,
          retryAfterMs: error.retryAfterMs,
        });
      }
      // For Redis errors, pass through but log
      next();
    }
  };
}

"""Production-grade CSV to PostgreSQL pipeline with validation and error handling
Dependencies: pandas (https://github.com/pandas-dev/pandas), sqlalchemy (https://github.com/sqlalchemy/sqlalchemy), psycopg2-binary
"""
import os
import logging
from typing import List, Dict, Any
import pandas as pd
from sqlalchemy import create_engine, Engine, text
from sqlalchemy.exc import SQLAlchemyError
from pandas.errors import ParserError, EmptyDataError

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

# Configuration dataclass
class PipelineConfig:
    def __init__(
        self,
        csv_path: str,
        db_connection_string: str,
        target_table: str,
        required_columns: List[str],
        chunk_size: int = 1000
    ):
        self.csv_path = csv_path
        self.db_connection_string = db_connection_string
        self.target_table = target_table
        self.required_columns = required_columns
        self.chunk_size = chunk_size

        # Validate config on initialization
        if not os.path.exists(csv_path):
            raise FileNotFoundError(f"CSV file not found at {csv_path}")
        if chunk_size <= 0:
            raise ValueError("chunk_size must be positive")

def validate_dataframe(df: pd.DataFrame, required_columns: List[str]) -> None:
    """Validate that dataframe has required columns and no null values in critical fields"""
    missing_cols = [col for col in required_columns if col not in df.columns]
    if missing_cols:
        raise ValueError(f"Missing required columns: {missing_cols}")

    # Check for nulls in required columns
    null_counts = df[required_columns].isnull().sum()
    if null_counts.any():
        raise ValueError(f"Null values found in required columns: {null_counts[null_counts > 0].to_dict()}")

def process_csv_chunk(chunk: pd.DataFrame, engine: Engine, table: str) -> int:
    """Process a single chunk of CSV data, return number of rows inserted"""
    try:
        # Clean data: strip whitespace from string columns
        for col in chunk.select_dtypes(include=['object']).columns:
            chunk[col] = chunk[col].str.strip()

        # Write to Postgres
        chunk.to_sql(
            name=table,
            con=engine,
            if_exists='append',
            index=False,
            method='multi'  # Batch insert for performance
        )
        return len(chunk)
    except SQLAlchemyError as e:
        logger.error(f"Database error processing chunk: {e}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error processing chunk: {e}")
        raise

def run_pipeline(config: PipelineConfig) -> int:
    """Run the full pipeline, return total rows inserted"""
    total_rows = 0
    engine = None

    try:
        # Initialize DB engine
        engine = create_engine(config.db_connection_string)

        # Test DB connection
        with engine.connect() as conn:
            conn.execute(text("SELECT 1"))
        logger.info("Database connection successful")

        # Read CSV in chunks
        logger.info(f"Reading CSV from {config.csv_path}")
        chunk_iter = pd.read_csv(
            config.csv_path,
            chunksize=config.chunk_size,
            dtype=str,  # Read all as string first for validation
            keep_default_na=False  # Treat empty strings as valid, not NaN
        )

        for chunk_num, chunk in enumerate(chunk_iter):
            logger.info(f"Processing chunk {chunk_num + 1} ({len(chunk)} rows)")

            # Validate chunk
            validate_dataframe(chunk, config.required_columns)

            # Process chunk
            rows_inserted = process_csv_chunk(chunk, engine, config.target_table)
            total_rows += rows_inserted
            logger.info(f"Inserted {rows_inserted} rows from chunk {chunk_num + 1}")

        logger.info(f"Pipeline completed. Total rows inserted: {total_rows}")
        return total_rows

    except (ParserError, EmptyDataError) as e:
        logger.error(f"CSV parsing error: {e}")
        raise
    except SQLAlchemyError as e:
        logger.error(f"Database connection error: {e}")
        raise
    except Exception as e:
        logger.error(f"Pipeline failed: {e}")
        raise
    finally:
        if engine:
            engine.dispose()
            logger.info("Database engine disposed")

if __name__ == "__main__":
    # Example usage
    try:
        pipeline_config = PipelineConfig(
            csv_path="./data/transactions.csv",
            db_connection_string="postgresql://user:pass@localhost:5432/analytics",
            target_table="transactions",
            required_columns=["transaction_id", "user_id", "amount", "timestamp"],
            chunk_size=500
        )
        run_pipeline(pipeline_config)
    except Exception as e:
        logger.error(f"Pipeline execution failed: {e}")
        exit(1)

// User registration endpoint for Go REST API
// Dependencies: github.com/gorilla/mux (https://github.com/gorilla/mux), golang.org/x/crypto/bcrypt (https://github.com/golang/crypto), database/sql
package main

import (
    "context"
    "database/sql"
    "encoding/json"
    "net/http"
    "time"

    "github.com/gorilla/mux"
    "golang.org/x/crypto/bcrypt"
)

// User registration request struct
type RegisterRequest struct {
    Email    string `json:"email"`
    Password string `json:"password"`
}

// User registration response struct
type RegisterResponse struct {
    ID    int64  `json:"id"`
    Email string `json:"email"`
}

// Custom error response struct
type ErrorResponse struct {
    Error string `json:"error"`
}

// Database interface for testability
type UserDB interface {
    CreateUser(ctx context.Context, email string, passwordHash string) (int64, error)
    GetUserByEmail(ctx context.Context, email string) (bool, error)
}

// MySQL implementation of UserDB
type MySQLUserDB struct {
    db *sql.DB
}

// CreateUser inserts a new user into the database
func (m *MySQLUserDB) CreateUser(ctx context.Context, email string, passwordHash string) (int64, error) {
    query := "INSERT INTO users (email, password_hash, created_at) VALUES (?, ?, ?)"
    result, err := m.db.ExecContext(ctx, query, email, passwordHash, time.Now())
    if err != nil {
        return 0, err
    }
    return result.LastInsertId()
}

// GetUserByEmail checks if a user with the given email exists
func (m *MySQLUserDB) GetUserByEmail(ctx context.Context, email string) (bool, error) {
    query := "SELECT 1 FROM users WHERE email = ? LIMIT 1"
    var exists int
    err := m.db.QueryRowContext(ctx, query, email).Scan(&exists)
    if err == sql.ErrNoRows {
        return false, nil
    }
    if err != nil {
        return false, err
    }
    return true, nil
}

// RegisterHandler handles user registration requests
func RegisterHandler(userDB UserDB) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        w.Header().Set("Content-Type", "application/json")

        // Only accept POST requests
        if r.Method != http.MethodPost {
            w.WriteHeader(http.StatusMethodNotAllowed)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "method not allowed"})
            return
        }

        // Parse request body
        var req RegisterRequest
        if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
            w.WriteHeader(http.StatusBadRequest)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "invalid request body"})
            return
        }

        // Validate input
        if req.Email == "" || req.Password == "" {
            w.WriteHeader(http.StatusBadRequest)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "email and password are required"})
            return
        }
        if len(req.Password) < 8 {
            w.WriteHeader(http.StatusBadRequest)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "password must be at least 8 characters"})
            return
        }

        // Check if user already exists
        exists, err := userDB.GetUserByEmail(ctx, req.Email)
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "failed to check existing user"})
            return
        }
        if exists {
            w.WriteHeader(http.StatusConflict)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "user with this email already exists"})
            return
        }

        // Hash password
        passwordHash, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "failed to hash password"})
            return
        }

        // Create user
        userID, err := userDB.CreateUser(ctx, req.Email, string(passwordHash))
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            json.NewEncoder(w).Encode(ErrorResponse{Error: "failed to create user"})
            return
        }

        // Return success response
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(RegisterResponse{
            ID:    userID,
            Email: req.Email,
        })
    }
}

func main() {
    // Initialize router and DB (simplified for example)
    r := mux.NewRouter()
    // db := sql.Open(...) // Initialize actual DB connection here
    // userDB := &MySQLUserDB{db: db}
    // r.HandleFunc("/register", RegisterHandler(userDB)).Methods(http.MethodPost)
    // http.ListenAndServe(":8080", r)
}

// Short snippet: ESLint config to flag high complexity
module.exports = {
  rules: {
    'complexity': ['error', { max: 5 }],
    'no-redeclare': 'error',
    'no-unused-vars': 'error'
  }
};

# Short snippet: Flake8 config to flag deprecated APIs
[flake8]
max-complexity = 5
ignore = E203, W503
select = B,B9  # Bugbear and security rules

// Short snippet: Go test for rebuilt user registration endpoint
func TestRegisterHandler(t *testing.T) {
    // Test cases for manual vs Copilot-generated endpoint
}