import { CaptchaClient, ICaptchaValidationRequest } from "x-captcha-client";

// Initialize the client with your API URL
const captchaClient = new CaptchaClient({
    apiUrl: "https://api.xcaptcha.com/v1",
});

// Get a captcha challenge
async function loadCaptcha() {
    try {
        const challenge = await captchaClient.getChallenge();
        console.log("Challenge received:", challenge);

        // Render your captcha UI using the challenge data
        // challenge.id - unique identifier for this challenge
        // challenge.type - type of challenge (e.g., 'click')
        // challenge.createdAt - when the challenge was created
        // challenge.expiresAt - when the challenge expires

        return challenge;
    } catch (error) {
        console.error("Failed to load captcha:", error);
    }
}

// Validate a captcha response
async function validateCaptcha(challengeId: string, userResponse: any) {
    try {
        const validationRequest: ICaptchaValidationRequest = {
            challengeId,
            response: userResponse,
        };

        const result = await captchaClient.validate(validationRequest);

        if (result.isSuccess) {
            console.log("Validation successful! Token:", result.token);
            return result.token; // Use this token for subsequent API calls
        } else {
            console.error("Validation failed:", result.error);
            return null;
        }
    } catch (error) {
        console.error("Error during validation:", error);
        return null;
    }
}

import express from "express";
import { CaptchaClient } from "x-captcha-client";

const app = express();
app.use(express.json());

// Create a captcha client instance
const captchaClient = new CaptchaClient({
    apiUrl: process.env.XCAPTCHA_API_URL || "https://api.xcaptcha.com/v1",
});

// Middleware to validate captcha tokens
const validateCaptchaToken = async (req, res, next) => {
    const { captchaId, captchaResponse } = req.body;

    if (!captchaId || !captchaResponse) {
        return res.status(400).json({ error: "Missing captcha information" });
    }

    try {
        const validationResult = await captchaClient.validate({
            challengeId: captchaId,
            response: captchaResponse,
        });

        if (!validationResult.isSuccess) {
            return res.status(403).json({ error: "Captcha validation failed", details: validationResult.error });
        }

        // Store validation result for use in route handlers
        req.captchaValidated = true;
        req.captchaToken = validationResult.token;
        next();
    } catch (error) {
        console.error("Captcha validation error:", error);
        return res.status(500).json({ error: "Failed to validate captcha" });
    }
};

// Example protected route
app.post("/api/protected-action", validateCaptchaToken, (req, res) => {
    // If we get here, the captcha was validated successfully
    res.json({ success: true, message: "Action completed successfully" });
});

app.listen(3000, () => {
    console.log("Server running on port 3000");
});

import {
    ICaptchaApiClient,
    ICaptchaChallenge,
    ICaptchaValidationRequest,
    ICaptchaValidationResult,
} from "x-captcha-client";

class CustomCaptchaApiClient implements ICaptchaApiClient {
    constructor(
        private readonly apiUrl: string,
        private readonly apiKey: string,
    ) {}

    async fetchChallenge(): Promise<ICaptchaChallenge> {
        const response = await fetch(`${this.apiUrl}/challenge`, {
            headers: {
                Authorization: `Bearer ${this.apiKey}`,
                "X-Custom-Header": "CustomValue",
            },
        });

        if (!response.ok) {
            throw new Error(`Failed to fetch challenge: ${response.statusText}`);
        }

        const data = await response.json();

        return {
            ...data,
            createdAt: new Date(data.createdAt),
            expiresAt: new Date(data.expiresAt),
        };
    }

    async validateChallenge(request: ICaptchaValidationRequest): Promise<ICaptchaValidationResult> {
        const response = await fetch(`${this.apiUrl}/validate`, {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
                Authorization: `Bearer ${this.apiKey}`,
                "X-Custom-Header": "CustomValue",
            },
            body: JSON.stringify(request),
        });

        if (!response.ok) {
            return {
                isSuccess: false,
                error: `Request failed: ${response.statusText}`,
            };
        }

        return await response.json();
    }
}

// Then create a CaptchaService with your custom client
import { CaptchaService } from "x-captcha-client";

const apiClient = new CustomCaptchaApiClient("https://api.xcaptcha.com/v1", "your-api-key");
const captchaService = new CaptchaService(apiClient);

// Use the service directly
const challenge = await captchaService.getChallenge();

import { ElsiKoraApiClient } from "@elsikora/x-captcha-client";

const client = new ElsiKoraApiClient({ apiKey: "YOUR_API_KEY", secretKey: "YOUR_SECRET_KEY" });
await client.challenge.challengeControllerSolve("ee2e5799-8df3-4a80-bed0-25f30abbe744", {
    solution: {
        type: "click",
        data: true,
    },
});

import { ElsiKoraApi } from "@elsikora/x-captcha-client";

const request: ElsiKoraApi.ChallengeSolveRequestBodyDto = {
    ...
};

import { ElsiKoraApiError } from "@elsikora/x-captcha-client";

try {
    await client.challenge.challengeControllerSolve(...);
} catch (err) {
    if (err instanceof ElsiKoraApiError) {
        console.log(err.statusCode);
        console.log(err.message);
        console.log(err.body);
    }
}

const response = await client.challenge.challengeControllerSolve(..., {
    headers: {
        'X-Custom-Header': 'custom value'
    }
});

const response = await client.challenge.challengeControllerSolve(..., {
    maxRetries: 0 // override maxRetries at the request level
});

const response = await client.challenge.challengeControllerSolve(..., {
    timeoutInSeconds: 30 // override timeout to 30s
});

const controller = new AbortController();
const response = await client.challenge.challengeControllerSolve(..., {
    abortSignal: controller.signal
});
controller.abort(); // aborts the request

import { ElsiKoraApiClient } from "@elsikora/x-captcha-client";

const client = new ElsiKoraApiClient({
    ...
    fetcher: // provide your implementation here
});