slp-modular-cms/frontend/src/api/useInvitation.ts

import { useState, useCallback, useEffect } from 'react';
import { api } from '../lib/api-client';

interface InvitationValidationResponse {
    valid: boolean;
    email?: string;
    error?: string;
}

interface InvitationCompleteRequest {
    token: string;
    name: string;
    password: string;
}

interface InvitationCompleteResponse {
    message: string;
    user: {
        id: string;
        name: string;
        email: string;
        role: string;
    };
}

export function useValidateInvitation(token: string | null) {
    const [data, setData] = useState<InvitationValidationResponse | null>(null);
    const [isPending, setIsPending] = useState(false);
    const [error, setError] = useState<Error | null>(null);

    useEffect(() => {
        if (!token) return;

        const fetchValidation = async () => {
            setIsPending(true);
            setError(null);
            try {
                const url = `/api/v1/Invitation/validate?token=${encodeURIComponent(token)}`;
                const response = await api.get(url);
                setData(response as InvitationValidationResponse);
            } catch (err: unknown) {
                setError(err instanceof Error ? err : new Error(String(err)));
                setData(null);
            } finally {
                setIsPending(false);
            }
        };

        fetchValidation();
    }, [token]);

    return {
        data,
        isPending,
        error
    };
}

export function useCompleteInvitation() {
    const [isPending, setIsPending] = useState(false);
    const [error, setError] = useState<Error | null>(null);

    const mutateAsync = useCallback(async (data: InvitationCompleteRequest): Promise<InvitationCompleteResponse> => {
        setIsPending(true);
        setError(null);
        try {
            const response = await api.post('/api/v1/Invitation/complete', data);
            return response as InvitationCompleteResponse;
        } catch (err: unknown) {
            const error = err instanceof Error ? err : new Error(String(err));
            setError(error);
            throw error;
        } finally {
            setIsPending(false);
        }
    }, []);

    return {
        mutateAsync,
        isPending,
        error
    };
}