Connecting Your Project to Nazexa Socket Platform

'use client';

import { useEffect, useState, useRef, useCallback } from 'react';
import { io, Socket } from 'socket.io-client';

export function useNazexaSocket({
  url = 'https://ws.nazexa.com',
  token,
  tokenEndpoint = '/api/socket-token',
  room,
}: {
  url?: string;
  token?: string;
  tokenEndpoint?: string;
  room?: string;
} = {}) {
  const [isConnected, setIsConnected] = useState(false);
  const [socketId, setSocketId] = useState<string | null>(null);
  const [error, setError] = useState<string | null>(null);
  const socketRef = useRef<Socket | null>(null);

  useEffect(() => {
    let isCancelled = false;
    let currentSocket: Socket | null = null;

    async function init() {
      try {
        let activeToken = token;
        if (!activeToken && tokenEndpoint) {
          const res = await fetch(tokenEndpoint);
          const data = await res.json();
          activeToken = data.token;
        }

        if (isCancelled) return;

        const socketInstance: Socket = io(url, {
          path: '/socket.io',
          auth: { token: activeToken },
          transports: ['websocket', 'polling'],
        });

        currentSocket = socketInstance;
        socketRef.current = socketInstance;

        socketInstance.on('connect', () => {
          if (!isCancelled) {
            setIsConnected(true);
            setSocketId(socketInstance.id || null);
            if (room) socketInstance.emit('room:join', room);
          }
        });

        socketInstance.on('disconnect', () => {
          if (!isCancelled) setIsConnected(false);
        });

        socketInstance.on('connect_error', (err) => {
          if (!isCancelled) setError(err.message);
        });
      } catch (err: any) {
        if (!isCancelled) setError(err.message);
      }
    }

    void init();

    return () => {
      isCancelled = true;
      currentSocket?.disconnect();
    };
  }, [url, token, tokenEndpoint, room]);

  const emitEvent = useCallback((event: string, data: unknown, targetRoom?: string) => {
    socketRef.current?.emit('event:emit', {
      event,
      room: targetRoom || room,
      data,
    });
  }, [room]);

  return { socket: socketRef.current, isConnected, socketId, error, emitEvent };
}

// 1. Define your payload interface
interface DocumentPayload {
  documentId: string;
  savedBy: string;
  updatedAt: string;
}

// 2. Publishing an event to a room from client
socket.emit('event:emit', {
  room: 'project:abc1234',
  event: 'document:saved',
  data: {
    documentId: 'doc_55',
    savedBy: 'alex',
    updatedAt: new Date().toISOString(),
  } satisfies DocumentPayload,
});

// 3. Listening for that event with strict typing
socket.on('document:saved', (payload: DocumentPayload) => {
  console.log('Document updated by peer:', payload.savedBy);
});

// lib/nazexa-emitter.ts
export async function emitServerEvent(room: string, event: string, data: unknown) {
  const res = await fetch('https://ws.nazexa.com/internal/emit', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      projectId: process.env.NAZEXA_PROJECT_ID,
      secretKey: process.env.NAZEXA_SECRET_KEY,
      room,
      event,
      data,
    }),
  });

  if (!res.ok) {
    throw new Error('Failed to emit real-time event');
  }
}