Modernization roadmap

import { z } from 'zod';
import dotenv from 'dotenv';

dotenv.config();

const envSchema = z.object({
  TOKEN: z.string().min(1, 'Discord token is required'),
  MONGO_URI: z.string().url('Valid MongoDB URI is required'),
  CLIENT_ID: z.string().min(1, 'Client ID is required'),
  NODE_ENV: z.enum(['development', 'production']).default('development')
});

export const env = envSchema.parse(process.env);

export class RateLimiter {
  private requests: Map<string, number[]> = new Map();
  
  constructor(
    private readonly maxRequests: number,
    private readonly timeWindow: number
  ) {}
  
  canMakeRequest(userId: string): boolean {
    const now = Date.now();
    const userRequests = this.requests.get(userId) || [];
    
    // Remove old requests outside time window
    const validRequests = userRequests.filter(
      timestamp => now - timestamp < this.timeWindow
    );
    
    if (validRequests.length >= this.maxRequests) {
      return false;
    }
    
    validRequests.push(now);
    this.requests.set(userId, validRequests);
    return true;
  }
}

import winston from 'winston';

export const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ 
      filename: 'logs/error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'logs/combined.log' 
    })
  ]
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

FROM node:20-alpine

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy source
COPY . .

# Build TypeScript (if using TS)
RUN npm run build

# Create non-root user
RUN addgroup -g 1001 -S yato && \
    adduser -S yato -u 1001
USER yato

CMD ["node", "dist/index.js"]

version: '3.8'

services:
  bot:
    build: .
    restart: unless-stopped
    env_file: .env
    depends_on:
      - mongodb
    volumes:
      - ./logs:/app/logs
  
  mongodb:
    image: mongo:7
    restart: unless-stopped
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD}
    volumes:
      - mongodb_data:/data/db

volumes:
  mongodb_data:

import { PingCommand } from '../../src/commands/ping';
import { MockInteraction } from '../mocks/interaction';

describe('Ping Command', () => {
  it('should respond with latency', async () => {
    const interaction = new MockInteraction();
    const command = new PingCommand();
    
    await command.execute(interaction);
    
    expect(interaction.replied).toBe(true);
    expect(interaction.lastReply).toMatch(/Pong/);
  });
});