Hata Yönetimi ve Debugging

// Temel Error sınıfından miras alan özel hata sınıfı
class ValidationError extends Error {
    constructor(message) {
        super(message);
        this.name = "ValidationError";
        this.code = "E_VALIDATION";
    }
}

// Başka bir özel hata sınıfı
class DatabaseError extends Error {
    constructor(message, query) {
        super(message);
        this.name = "DatabaseError";
        this.code = "E_DATABASE";
        this.query = query;
    }
}

// Özel hataları kullanma
function validateUser(user) {
    if (!user) {
        throw new ValidationError("Kullanıcı nesnesi gereklidir.");
    }
    
    if (!user.username) {
        throw new ValidationError("Kullanıcı adı gereklidir.");
    }
    
    if (user.username.length < 3) {
        throw new ValidationError("Kullanıcı adı en az 3 karakter olmalıdır.");
    }
    
    return true;
}

function queryDatabase(query) {
    if (!query) {
        throw new DatabaseError("Sorgu boş olamaz.", query);
    }
    
    // Veritabanı sorgusu simülasyonu
    if (query.includes("DROP")) {
        throw new DatabaseError("Tehlikeli sorgu tespit edildi.", query);
    }
    
    return { success: true, data: "Sorgu sonuçları" };
}

// Hataları yakalama ve işleme
try {
    // Geçersiz kullanıcı
    validateUser({ username: "ab" });
} catch (error) {
    if (error instanceof ValidationError) {
        console.error(`Doğrulama hatası: ${error.message}`);
    } else {
        console.error(`Beklenmeyen hata: ${error.message}`);
    }
}

try {
    // Tehlikeli sorgu
    queryDatabase("DROP TABLE users");
} catch (error) {
    if (error instanceof DatabaseError) {
        console.error(`Veritabanı hatası: ${error.message}`);
        console.error(`Sorunlu sorgu: ${error.query}`);
    } else {
        console.error(`Beklenmeyen hata: ${error.message}`);
    }
}

try {
    // Hata oluşturabilecek kod
    const result = riskyOperation();
    console.log("İşlem başarılı:", result);
} catch (error) {
    // Hata durumunda çalışacak kod
    console.error("Bir hata oluştu:", error.message);
} finally {
    // Hata olsun veya olmasın her zaman çalışacak kod
    console.log("İşlem tamamlandı.");
}

function getUserData(userId) {
    try {
        // Kullanıcı verisini almaya çalış
        const userData = fetchUserFromDatabase(userId);
        
        // Veri işleme
        const processedData = processUserData(userData);
        
        return processedData;
    } catch (error) {
        // Hata türüne göre işleme
        if (error.name === "DatabaseError") {
            console.error("Veritabanı hatası:", error.message);
            // Yedek veri kaynağını dene
            return fetchUserFromBackupSource(userId);
        } else if (error.name === "ProcessingError") {
            console.error("İşleme hatası:", error.message);
            // Temel veriyi döndür
            return { userId, name: "Bilinmeyen Kullanıcı", isBackup: true };
        } else {
            // Beklenmeyen hatalar için
            console.error("Beklenmeyen hata:", error);
            throw error; // Hatayı yeniden fırlat
        }
    } finally {
        // Temizlik işlemleri
        closeConnections();
        logAccessAttempt(userId);
    }
}

// Simüle edilmiş fonksiyonlar
function fetchUserFromDatabase(userId) {
    if (userId < 0) {
        const error = new Error("Geçersiz kullanıcı ID'si");
        error.name = "DatabaseError";
        throw error;
    }
    
    if (userId === 0) {
        return null; // Kullanıcı bulunamadı
    }
    
    return { userId, name: "John Doe", email: "john@example.com" };
}

function processUserData(userData) {
    if (!userData) {
        const error = new Error("Kullanıcı verisi bulunamadı");
        error.name = "ProcessingError";
        throw error;
    }
    
    return {
        ...userData,
        displayName: userData.name.toUpperCase(),
        lastAccess: new Date().toISOString()
    };
}

function fetchUserFromBackupSource(userId) {
    return { userId, name: "John Doe (Yedek)", email: "john@backup.com", isBackup: true };
}

function closeConnections() {
    console.log("Bağlantılar kapatıldı.");
}

function logAccessAttempt(userId) {
    console.log(`Kullanıcı ID ${userId} için erişim girişimi kaydedildi.`);
}

// Fonksiyonu test etme
try {
    console.log(getUserData(1)); // Normal durum
    console.log(getUserData(0)); // Kullanıcı bulunamadı
    console.log(getUserData(-1)); // Veritabanı hatası
} catch (error) {
    console.error("Ana programda hata yakalandı:", error.message);
}

try {
    // Bir hata oluştur
    throw new Error("Bu bir test hatasıdır");
} catch (error) {
    console.log("Hata Türü:", error.name);
    console.log("Hata Mesajı:", error.message);
    console.log("Çağrı Yığını:", error.stack);
}

// ES2022+ özelliği: Error Cause
try {
    try {
        // İç hata
        throw new Error("Veritabanı bağlantısı başarısız");
    } catch (dbError) {
        // Dış hata (iç hatayı neden olarak belirt)
        throw new Error("Kullanıcı verisi alınamadı", { cause: dbError });
    }
} catch (error) {
    console.log("Ana Hata:", error.message);
    console.log("Neden Olan Hata:", error.cause?.message);
}

// Promise ile hata yakalama
function fetchData(url) {
    return fetch(url)
        .then(response => {
            if (!response.ok) {
                throw new Error(`HTTP error! Status: ${response.status}`);
            }
            return response.json();
        })
        .then(data => {
            console.log("Veri başarıyla alındı:", data);
            return data;
        })
        .catch(error => {
            console.error("Veri alınırken hata oluştu:", error.message);
            // Hata durumunda varsayılan veri döndür
            return { error: true, message: error.message };
        })
        .finally(() => {
            console.log("Fetch işlemi tamamlandı.");
        });
}

// Promise zincirinde hata yayılımı
function processUserData(userId) {
    return fetchUserById(userId)
        .then(user => {
            if (!user) {
                throw new Error("Kullanıcı bulunamadı");
            }
            return fetchUserPosts(user.id);
        })
        .then(posts => {
            return { success: true, posts };
        })
        .catch(error => {
            console.error("İşlem hatası:", error.message);
            return { success: false, error: error.message };
        });
}

// Simüle edilmiş fonksiyonlar
function fetchUserById(userId) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (userId === 0) {
                resolve(null);
            } else if (userId < 0) {
                reject(new Error("Geçersiz kullanıcı ID'si"));
            } else {
                resolve({ id: userId, name: "John Doe" });
            }
        }, 500);
    });
}

function fetchUserPosts(userId) {
    return new Promise((resolve, reject) => {
        setTimeout(() => {
            if (userId === 1) {
                resolve([
                    { id: 1, title: "İlk Gönderi" },
                    { id: 2, title: "İkinci Gönderi" }
                ]);
            } else {
                reject(new Error("Gönderiler alınamadı"));
            }
        }, 500);
    });
}

// Async/await ile hata yakalama
async function fetchData(url) {
    try {
        const response = await fetch(url);
        
        if (!response.ok) {
            throw new Error(`HTTP error! Status: ${response.status}`);
        }
        
        const data = await response.json();
        console.log("Veri başarıyla alındı:", data);
        return data;
    } catch (error) {
        console.error("Veri alınırken hata oluştu:", error.message);
        // Hata durumunda varsayılan veri döndür
        return { error: true, message: error.message };
    } finally {
        console.log("Fetch işlemi tamamlandı.");
    }
}

// Async/await ile daha karmaşık hata yönetimi
async function processUserData(userId) {
    try {
        const user = await fetchUserById(userId);
        
        if (!user) {
            throw new Error("Kullanıcı bulunamadı");
        }
        
        const posts = await fetchUserPosts(user.id);
        return { success: true, user, posts };
    } catch (error) {
        console.error("İşlem hatası:", error.message);
        
        // Hata türüne göre farklı işlemler
        if (error.message.includes("Geçersiz kullanıcı")) {
            return { success: false, error: "Kullanıcı bilgisi geçersiz", code: "INVALID_USER" };
        } else if (error.message.includes("bulunamadı")) {
            return { success: false, error: "Kullanıcı mevcut değil", code: "USER_NOT_FOUND" };
        } else {
            return { success: false, error: error.message, code: "UNKNOWN_ERROR" };
        }
    }
}

// Birden fazla asenkron işlemi paralel yürütme ve hata yakalama
async function fetchMultipleResources() {
    try {
        // Promise.all tüm promise'ların tamamlanmasını bekler
        // Herhangi biri başarısız olursa, hata fırlatır
        const [users, posts, comments] = await Promise.all([
            fetchUsers(),
            fetchPosts(),
            fetchComments()
        ]);
        
        return { users, posts, comments };
    } catch (error) {
        console.error("Kaynaklar alınırken hata oluştu:", error.message);
        return { error: true, message: "Veriler alınamadı" };
    }
}

// Promise.allSettled ile tüm sonuçları alma (başarılı veya başarısız)
async function fetchAllResourcesWithStatus() {
    const results = await Promise.allSettled([
        fetchUsers(),
        fetchPosts(),
        fetchComments()
    ]);
    
    // Her bir sonucun durumunu kontrol et
    return results.map((result, index) => {
        const resourceType = ["users", "posts", "comments"][index];
        
        if (result.status === "fulfilled") {
            return { type: resourceType, status: "success", data: result.value };
        } else {
            return { type: resourceType, status: "error", error: result.reason.message };
        }
    });
}