{
  "scripts": {
    "dev": "nodemon",           // Start development server with hot reload
    "start": "node dist/index.js" // Start production server
  }
}

{
  "scripts": {
    "dev": "next dev -p 8030",    // Start development server on port 8030
    "build": "next build",         // Build for production
    "start": "next start -p 8030", // Start production server
    "lint": "eslint"                // Run ESLint
  }
}

import { apiFetch } from '../utils/apiFetch';
import { cookies } from 'next/headers';

export async function registerUser(userData: any) {
  const res = await apiFetch('/auth/register', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(userData),
  });

  const data = await res.json();

  if (!res.ok) {
    throw new Error(data.message || 'Error al registrar el usuario');
  }

  // Store JWT token in HTTP-only cookie
  const cookieStore = await cookies();
  cookieStore.set('horse_trust_token', data.token, { 
    httpOnly: true, 
    secure: process.env.NODE_ENV === 'production',
    maxAge: 60 * 60 * 24 * 7, // 7 days
    path: '/',
  });

  return { success: true, data };
}

import { apiFetch } from '../utils/apiFetch';
import { cookies } from 'next/headers';
import { revalidatePath } from 'next/cache';

export async function createHorse(horseData: any) {
  const cookieStore = await cookies();
  const token = cookieStore.get('horse_trust_token')?.value;

  if (!token) {
    return { success: false, error: "No hay una sesión activa" };
  }

  const res = await apiFetch('/horses', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}` 
    },
    body: JSON.stringify(horseData),
  });

  const data = await res.json();

  if (!res.ok) {
    return { success: false, error: data.error || "Error al publicar el caballo" };
  }

  // Revalidate relevant pages
  revalidatePath('/marketplace'); 
  revalidatePath('/dashboard'); 
  
  return { success: true, data };
}

import { Server as SocketServer } from "socket.io";
import jwt from "jsonwebtoken";

const io = new SocketServer(httpServer, {
  cors: {
    origin: process.env.CORS_ORIGINS.split(","),
    credentials: true,
  },
});

// JWT authentication for socket connections
io.use((socket, next) => {
  const token = socket.handshake.auth?.token;
  if (!token) {
    return next(new Error("Authentication error: no token"));
  }
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    socket.user = decoded;
    next();
  } catch {
    next(new Error("Authentication error: invalid token"));
  }
});

io.on("connection", (socket) => {
  // Join user-specific room
  socket.join(`user:${socket.user.userId}`);
  
  // Join conversation room
  socket.on("join_conversation", (conversationId) => {
    socket.join(`conv:${conversationId}`);
  });
  
  // Send message
  socket.on("send_message", async (data, ack) => {
    // Message handling logic...
  });
});

export async function apiFetch(endpoint: string, options: RequestInit = {}) {
  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
  const url = `${apiUrl}${endpoint}`;

  try {
    let res = await fetch(url, options);

    // Auto-retry with database reconnection on 5xx errors
    if (!res.ok && res.status >= 500) {
      console.log(`API failed. Attempting to wake Oracle...`);
      
      const reconRes = await fetch(`${apiUrl}/health/reconnect`, { 
        method: 'POST' 
      });
      
      if (reconRes.ok) {
        console.log(`DB reconnected. Retrying request...`);
        res = await fetch(url, options);
      }
    }

    return res;
  } catch (error) {
    console.error(`Network error. Attempting reconnect...`, error);
    await fetch(`${apiUrl}/health/reconnect`, { method: 'POST' });
    return await fetch(url, options);
  }
}