Manipuladores Globais de Erro

// src/bootstrap/installGlobalErrorHandlers.ts
// Importe isso uma vez a partir do seu ponto de entrada do aplicativo (index.js / _layout.tsx) antes de outro código do aplicativo.
 
type GlobalHandler = (error: Error, isFatal?: boolean) => void;
 
declare const ErrorUtils: {
  getGlobalHandler(): GlobalHandler;
  setGlobalHandler(handler: GlobalHandler): void;
};
 
export function installGlobalErrorHandlers(report: (error: Error, meta: { isFatal: boolean }) => void) {
  const previous = ErrorUtils.getGlobalHandler();
 
  ErrorUtils.setGlobalHandler((error, isFatal = false) => {
    report(error, { isFatal });
    previous(error, isFatal);
  });
}

// app/_layout.tsx (root do Expo Router) - chame antes de renderizar provedores
import { installGlobalErrorHandlers } from "@/bootstrap/installGlobalErrorHandlers";
import { Stack } from "expo-router";
 
installGlobalErrorHandlers((error, { isFatal }) => {
  console.error("[global]", isFatal ? "FATAL" : "non-fatal", error);
  // crashReporter.captureException(error, { extra: { isFatal } });
});
 
export default function RootLayout() {
  return <Stack />;
}

// installGlobalErrorHandlers.ts - módulo de bootstrap completo
type GlobalHandler = (error: Error, isFatal?: boolean) => void;
 
declare const ErrorUtils: {
  getGlobalHandler(): GlobalHandler;
  setGlobalHandler(handler: GlobalHandler): void;
};
 
export type ErrorReport = {
  message: string;
  stack?: string;
  isFatal: boolean;
  kind: "global" | "unhandled-rejection";
};
 
const reports: ErrorReport[] = [];
 
export function getCapturedReports() {
  return [...reports];
}
 
function normalizeError(reason: unknown): Error {
  if (reason instanceof Error) return reason;
  return new Error(typeof reason === "string" ? reason : JSON.stringify(reason));
}
 
function record(error: Error, meta: { isFatal: boolean; kind: ErrorReport["kind"] }) {
  reports.push({
    message: error.message,
    stack: error.stack,
    isFatal: meta.isFatal,
    kind: meta.kind,
  });
  console.error(`[${meta.kind}]`, meta.isFatal ? "FATAL" : "non-fatal", error.message);
}
 
export function installGlobalErrorHandlers() {
  const previous = ErrorUtils.getGlobalHandler();
 
  ErrorUtils.setGlobalHandler((error, isFatal = false) => {
    record(error, { isFatal, kind: "global" });
    previous(error, isFatal);
  });
 
  // Cinto e suspensórios: registro explícito de rejeição não tratada (Hermes / ferramentas de desenvolvimento RN também podem rotear isso)
  const g = globalThis as typeof globalThis & {
    onunhandledrejection?: (event: { reason?: unknown }) => void;
  };
 
  g.onunhandledrejection = (event) => {
    const error = normalizeError(event.reason);
    record(error, { isFatal: false, kind: "unhandled-rejection" });
  };
}
 
// --- Telas de demonstração ---
import { useEffect, useState } from "react";
import { Pressable, ScrollView, StyleSheet, Text, View } from "react-native";
 
installGlobalErrorHandlers();
 
function causeUnhandledRejection() {
  void Promise.reject(new Error("falha na sincronização de faturamento"));
}
 
function causeThrowInTimer() {
  setTimeout(() => {
    throw new Error("lançamento no timer fora do React");
  }, 0);
}
 
export default function App() {
  const [tick, setTick] = useState(0);
 
  useEffect(() => {
    const id = setInterval(() => setTick((t) => t + 1), 1000);
    return () => clearInterval(id);
  }, []);
 
  const latest = getCapturedReports().slice(-3);
 
  return (
    <ScrollView contentContainerStyle={styles.container}>
      <Text style={styles.title}>Manipuladores Globais de Erro</Text>
      <Text style={styles.sub}>Relógio: {tick}s (aplicativo ainda em execução)</Text>
 
      <Pressable style={styles.btn} onPress={causeUnhandledRejection}>
        <Text style={styles.btnLabel}>Disparar rejeição não tratada</Text>
      </Pressable>
 
      <Pressable style={styles.btn} onPress={causeThrowInTimer}>
        <Text style={styles.btnLabel}>Disparar lançamento no timer</Text>
      </Pressable>
 
      <Text style={styles.section}>Últimos relatórios capturados</Text>
      {latest.length === 0 && <Text style={styles.meta}>Ainda não há nada - toque em um botão acima.</Text>}
      {latest.map((r, i) => (
        <View key={`${r.message}-${i}`} style={styles.card}>
          <Text style={styles.cardTitle}>
            [{r.kind}] {r.isFatal ? "FATAL" : "non-fatal"}
          </Text>
          <Text style={styles.cardBody}>{r.message}</Text>
        </View>
      ))}
    </ScrollView>
  );
}
 
const styles = StyleSheet.create({
  container: { padding: 20, gap: 12 },
  title: { fontSize: 24, fontWeight: "800" },
  sub: { color: "#64748b" },
  section: { fontSize: 16, fontWeight: "700", marginTop: 8 },
  meta: { color: "#94a3b8" },
  btn: { backgroundColor: "#2563eb", padding: 14, borderRadius: 8 },
  btnLabel: { color: "#fff", fontWeight: "600", textAlign: "center" },
  card: { backgroundColor: "#f1f5f9", padding: 12, borderRadius: 8 },
  cardTitle: { fontWeight: "700", marginBottom: 4 },
  cardBody: { color: "#334155" },
});

// app/_layout.tsx - topo do arquivo, antes dos componentes
import { installGlobalErrorHandlers } from "@/bootstrap/installGlobalErrorHandlers";
import * as Sentry from "@sentry/react-native";
 
Sentry.init({ dsn: process.env.EXPO_PUBLIC_SENTRY_DSN });
 
installGlobalErrorHandlers((error, { isFatal }) => {
  Sentry.captureException(error, { extra: { isFatal } });
});
 
export default function RootLayout() {
  return <RootProviders />;
}

// Fronteira da API - prefira corrigir na origem
export async function fetchBalance(): Promise<number> {
  try {
    const res = await fetch("/api/balance");
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    const json = (await res.json()) as { balance: number };
    return json.balance;
  } catch (error) {
    // Converta para o tipo Result ou relance para um estado de erro controlado na tela
    throw error instanceof Error ? error : new Error("falha ao buscar saldo");
  }
}
 
// Tarefas "fire-and-forget" ainda devem lidar com falhas
void syncAnalytics().catch((error) => {
  console.warn("falha na sincronização de análises", error);
});

type ReportFn = (error: Error, meta: { isFatal: boolean }) => void;
 
declare const ErrorUtils: {
  getGlobalHandler(): (error: Error, isFatal?: boolean) => void;
  setGlobalHandler(handler: (error: Error, isFatal?: boolean) => void): void;
};
 
export function installGlobalErrorHandlers(report: ReportFn): void {
  const previous = ErrorUtils.getGlobalHandler();
  ErrorUtils.setGlobalHandler((error, isFatal = false) => {
    report(error, { isFatal: !!isFatal });
    previous(error, isFatal);
  });
}
 
function normalizeReason(reason: unknown): Error {
  if (reason instanceof Error) return reason;
  return new Error(String(reason));
}