# 1. Vérification des processus
lsof -i :3000

# 2. Nettoyage
rm -rf .next
rm -rf node_modules
bun install

# 3. Vérification des logs
tail -f logs/error.log

# 1. Vérification du service PostgreSQL
sudo service postgresql status

# 2. Test de connexion
psql -U user -d company_manager -c "\l"

# 3. Réinitialisation
bun prisma migrate reset --force

// Vérification des logs d'authentification
const checkAuthLogs = async (userId: string) => {
  const logs = await prisma.authLog.findMany({
    where: {
      userId,
      createdAt: {
        gte: new Date(Date.now() - 24 * 60 * 60 * 1000),
      },
    },
    orderBy: { createdAt: 'desc' },
  });
  
  return logs;
};

// Nettoyage des sessions
const cleanupSessions = async () => {
  await prisma.session.deleteMany({
    where: {
      expiresAt: {
        lt: new Date(),
      },
    },
  });
};

// Analyse des requêtes
const analyzeQuery = async (query: string) => {
  const result = await prisma.$queryRaw`
    EXPLAIN ANALYZE ${query}
  `;
  return result;
};

// Optimisation des index
const createIndexes = async () => {
  await prisma.$executeRaw`
    CREATE INDEX IF NOT EXISTS idx_orders_customer
    ON orders(customer_id)
  `;
};

// Monitoring mémoire
const checkMemoryUsage = () => {
  const used = process.memoryUsage();
  
  return {
    heapTotal: Math.round(used.heapTotal / 1024 / 1024),
    heapUsed: Math.round(used.heapUsed / 1024 / 1024),
    external: Math.round(used.external / 1024 / 1024),
  };
};

// Vérification des erreurs de sync
const checkSyncErrors = async () => {
  const errors = await prisma.syncError.findMany({
    orderBy: { timestamp: 'desc' },
    take: 10,
  });
  
  return errors;
};

// Réessai de synchronisation
const retrySyncFailures = async () => {
  const failures = await prisma.syncError.findMany({
    where: {
      retryCount: { lt: 3 },
    },
  });
  
  for (const failure of failures) {
    await syncService.retrySync(failure);
  }
};

# 1. Nettoyage du cache
rm -rf .next
rm -rf node_modules/.cache

# 2. Vérification des types
bun tsc --noEmit

# 3. Lint
bun lint

# 1. Nettoyage
rm -rf node_modules
rm bun.lockb

# 2. Installation propre
bun install --force

# 3. Vérification
bun dedupe

# 1. Vérification de l'état
bun prisma migrate status

# 2. Réparation
bun prisma migrate reset --skip-seed

# 3. Nouvelle tentative
bun prisma migrate deploy

# 1. Build avec debug
NODE_ENV=production DEBUG=* bun build

# 2. Vérification des assets
ls -la .next/static

# 3. Test de production
bun start

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

// Utilisation
const logError = (error: Error, context: any) => {
  logger.error('Erreur application', {
    error: error.message,
    stack: error.stack,
    ...context,
  });
};

// Vérification système
const checkSystem = async () => {
  const metrics = {
    memory: process.memoryUsage(),
    cpu: process.cpuUsage(),
    uptime: process.uptime(),
    connections: await getActiveConnections(),
  };
  
  return metrics;
};

# Backup
pg_dump company_manager > backup.sql

# Restore
psql company_manager < backup.sql

// Nettoyage des données corrompues
const cleanupCorruptedData = async () => {
  await prisma.$transaction([
    prisma.session.deleteMany({
      where: { valid: false },
    }),
    prisma.syncError.deleteMany({
      where: {
        retryCount: { gte: 3 },
        createdAt: {
          lt: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
        },
      },
    }),
  ]);
};