Best Practices

src/
├── api/          # API routes
├── services/     # Business logic
├── models/       # Data models
├── repositories/ # Data access
├── middleware/   # Express middleware
├── utils/        # Utility functions
└── config/       # Configuration

// Good
async function getUserById(id: string): Promise<User>;
const isAuthenticated = checkAuth();

// Avoid
async function get(id: string): Promise<User>;
const auth = checkAuth();

class NotFoundError extends Error {
    constructor(resource: string, id: string) {
        super(`${resource} with id ${id} not found`);
        this.name = "NotFoundError";
    }
}

class ValidationError extends Error {
    constructor(message: string) {
        super(message);
        this.name = "ValidationError";
    }
}

app.use((err, req, res, next) => {
    logger.error(err);

    if (err instanceof ValidationError) {
        return res.status(400).json({ error: err.message });
    }

    if (err instanceof NotFoundError) {
        return res.status(404).json({ error: err.message });
    }

    // Default to 500 for unexpected errors
    res.status(500).json({
        error: "Internal server error",
    });
});

import { z } from "zod";

const createUserSchema = z.object({
    email: z.string().email(),
    password: z.string().min(8),
    name: z.string().min(1).max(100),
});

app.post("/users", async (req, res) => {
    const input = createUserSchema.parse(req.body);
    // ... create user
});

import bcrypt from "bcrypt";

async function hashPassword(password: string): Promise<string> {
    return bcrypt.hash(password, 12);
}

async function verifyPassword(
    password: string,
    hash: string
): Promise<boolean> {
    return bcrypt.compare(password, hash);
}

import Redis from "ioredis";

const redis = new Redis();

async function getUser(id: string): Promise<User> {
    // Check cache first
    const cached = await redis.get(`user:${id}`);
    if (cached) {
        return JSON.parse(cached);
    }

    // Fetch from database
    const user = await db.users.findOne({ id });

    // Store in cache (1 hour TTL)
    await redis.setex(`user:${id}`, 3600, JSON.stringify(user));

    return user;
}

describe("TaskService", () => {
    let service: TaskService;

    beforeEach(() => {
        service = new TaskService();
    });

    it("should create a task", async () => {
        const input = {
            title: "Test task",
            description: "Test description",
        };

        const task = await service.create(input);

        expect(task.id).toBeDefined();
        expect(task.title).toBe(input.title);
        expect(task.completed).toBe(false);
    });

    it("should find task by id", async () => {
        const created = await service.create({
            title: "Find me",
        });

        const found = await service.findById(created.id);

        expect(found).toEqual(created);
    });
});

describe("POST /tasks", () => {
    it("should create a task", async () => {
        const response = await request(app)
            .post("/tasks")
            .send({
                title: "Test task",
                description: "Test description",
            })
            .expect(201);

        expect(response.body).toMatchObject({
            title: "Test task",
            description: "Test description",
            completed: false,
        });
    });

    it("should return 400 for invalid input", async () => {
        await request(app).post("/tasks").send({ title: "" }).expect(400);
    });
});

import winston from "winston";

const logger = winston.createLogger({
    format: winston.format.json(),
    transports: [
        new winston.transports.File({ filename: "error.log", level: "error" }),
        new winston.transports.File({ filename: "combined.log" }),
    ],
});

logger.info("User created", {
    userId: user.id,
    email: user.email,
    timestamp: Date.now(),
});

const config = {
    nodeEnv: process.env.NODE_ENV || "development",
    port: parseInt(process.env.PORT || "3000"),
    databaseUrl: process.env.DATABASE_URL!,
    jwtSecret: process.env.JWT_SECRET!,
    logLevel: process.env.LOG_LEVEL || "info",
};

// Validate required variables
if (!config.databaseUrl) {
    throw new Error("DATABASE_URL is required");
}

app.get("/health", async (req, res) => {
    const checks = {
        database: await checkDatabase(),
        redis: await checkRedis(),
        uptime: process.uptime(),
    };

    const healthy = Object.values(checks).every(Boolean);

    res.status(healthy ? 200 : 503).json({
        status: healthy ? "healthy" : "unhealthy",
        checks,
    });
});

const server = app.listen(port);

process.on("SIGTERM", async () => {
    logger.info("SIGTERM received, shutting down gracefully");

    // Stop accepting new connections
    server.close(() => {
        logger.info("HTTP server closed");
    });

    // Close database connections
    await db.close();

    // Exit process
    process.exit(0);
});