Documentación para Desarrolladores

const fs = require('fs');
const FormData = require('form-data'); // npm install form-data

async function enviarDocumento(rutaArchivo, documentTypeId) {
  const form = new FormData();
  form.append('file', fs.createReadStream(rutaArchivo));
  form.append('document_type_id', documentTypeId);

  const response = await fetch('https://app.holalexy.com/api/ingest', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.LEXY_API_KEY}`,
      ...form.getHeaders(),
    },
    body: form,
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Error ${response.status}: ${error.error}`);
  }

  const { consulta_id } = await response.json();
  console.log('Consulta creada:', consulta_id);
  return consulta_id;
}

import os
import requests

def enviar_documento(ruta_archivo: str, document_type_id: str) -> str:
    api_key = os.environ['LEXY_API_KEY']

    with open(ruta_archivo, 'rb') as f:
        response = requests.post(
            'https://app.holalexy.com/api/ingest',
            headers={'Authorization': f'Bearer {api_key}'},
            files={'file': f},
            data={'document_type_id': document_type_id},
        )

    response.raise_for_status()
    consulta_id = response.json()['consulta_id']
    print(f'Consulta creada: {consulta_id}')
    return consulta_id

<?php
function enviarDocumento(string $rutaArchivo, string $documentTypeId): string {
    $apiKey = $_ENV['LEXY_API_KEY'];

    $curl = curl_init('https://app.holalexy.com/api/ingest');
    curl_setopt_array($curl, [
        CURLOPT_POST => true,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"],
        CURLOPT_POSTFIELDS => [
            'file' => new CURLFile($rutaArchivo),
            'document_type_id' => $documentTypeId,
        ],
    ]);

    $body = curl_exec($curl);
    $statusCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    curl_close($curl);

    if ($statusCode !== 202) {
        $error = json_decode($body, true);
        throw new Exception("Error $statusCode: " . $error['error']);
    }

    return json_decode($body, true)['consulta_id'];
}

const express = require('express');
const crypto = require('crypto');

const app = express();
const LEXY_SHARED_SECRET = process.env.LEXY_SHARED_SECRET;

// Importante: guardar el body crudo antes de parsear JSON
app.use('/webhook/lexy', express.raw({ type: 'application/json' }));

app.post('/webhook/lexy', (req, res) => {
  const signature = req.headers['x-lexy-signature'];

  if (!signature) {
    return res.status(401).json({ error: 'Firma ausente' });
  }

  const expected = crypto
    .createHmac('sha256', LEXY_SHARED_SECRET)
    .update(req.body) // req.body es Buffer gracias a express.raw()
    .digest('hex');

  const sigBuffer = Buffer.from(signature, 'utf8');
  const expBuffer = Buffer.from(expected, 'utf8');

  if (sigBuffer.length !== expBuffer.length ||
      !crypto.timingSafeEqual(sigBuffer, expBuffer)) {
    return res.status(401).json({ error: 'Firma inválida' });
  }

  const payload = JSON.parse(req.body.toString());
  console.log('Consulta completada:', payload.consulta_id);
  procesarAnalisis(payload.consulta_id, payload.analysis);

  res.status(200).json({ received: true });
});

import hashlib
import hmac
import os
from fastapi import FastAPI, Request, HTTPException

app = FastAPI()
LEXY_SHARED_SECRET = os.environ['LEXY_SHARED_SECRET']

@app.post('/webhook/lexy')
async def recibir_webhook(request: Request):
    signature = request.headers.get('x-lexy-signature')
    if not signature:
        raise HTTPException(status_code=401, detail='Firma ausente')

    body_bytes = await request.body()

    expected = hmac.new(
        LEXY_SHARED_SECRET.encode('utf-8'),
        body_bytes,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, signature):
        raise HTTPException(status_code=401, detail='Firma inválida')

    payload = await request.json()
    print(f"Consulta completada: {payload['consulta_id']}")

    return {'received': True}

import hashlib
import hmac
import json
import os
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST

LEXY_SHARED_SECRET = os.environ['LEXY_SHARED_SECRET']

@csrf_exempt
@require_POST
def webhook_lexy(request):
    signature = request.headers.get('X-Lexy-Signature')
    if not signature:
        return JsonResponse({'error': 'Firma ausente'}, status=401)

    expected = hmac.new(
        LEXY_SHARED_SECRET.encode('utf-8'),
        request.body,
        hashlib.sha256
    ).hexdigest()

    if not hmac.compare_digest(expected, signature):
        return JsonResponse({'error': 'Firma inválida'}, status=401)

    payload = json.loads(request.body)
    procesar_analisis(payload['consulta_id'], payload['analysis'])

    return JsonResponse({'received': True})

<?php
function verificarFirmaLexy(string $rawBody, string $signature): bool {
    $sharedSecret = $_ENV['LEXY_SHARED_SECRET'];
    $expected = hash_hmac('sha256', $rawBody, $sharedSecret);
    return hash_equals($expected, $signature);
}

$rawBody = file_get_contents('php://input');
$signature = $_SERVER['HTTP_X_LEXY_SIGNATURE'] ?? '';

if (!verificarFirmaLexy($rawBody, $signature)) {
    http_response_code(401);
    echo json_encode(['error' => 'Firma inválida']);
    exit;
}

$payload = json_decode($rawBody, true);
procesarAnalisis($payload['consulta_id'], $payload['analysis']);

http_response_code(200);
echo json_encode(['received' => true]);

import hashlib
import hmac
import os
from fastapi import FastAPI, HTTPException, Request
from fastapi.responses import JSONResponse
import httpx

LEXY_API_KEY = os.environ["LEXY_API_KEY"]
LEXY_SHARED_SECRET = os.environ["LEXY_SHARED_SECRET"]
LEXY_BASE_URL = os.environ["LEXY_BASE_URL"]
DOCUMENT_TYPE_ID = os.environ["LEXY_DOCUMENT_TYPE_ID"]

app = FastAPI()

# Set de idempotencia (en producción usa Redis o base de datos)
consultas_procesadas: set[str] = set()


# ─── Enviar documentos ────────────────────────────────────────

async def enviar_documento(ruta_archivo: str) -> str:
    async with httpx.AsyncClient() as client:
        with open(ruta_archivo, "rb") as f:
            response = await client.post(
                f"{LEXY_BASE_URL}/api/ingest",
                headers={"Authorization": f"Bearer {LEXY_API_KEY}"},
                files={"file": f},
                data={"document_type_id": DOCUMENT_TYPE_ID},
                timeout=30.0,
            )

    if response.status_code != 202:
        error = response.json().get("error", "Error desconocido")
        raise Exception(f"Error {response.status_code}: {error}")

    return response.json()["consulta_id"]


# ─── Webhook ─────────────────────────────────────────────────

@app.post("/webhook/lexy")
async def recibir_webhook(request: Request):
    # 1. Verificar firma
    signature = request.headers.get("x-lexy-signature")
    if not signature:
        raise HTTPException(status_code=401, detail="Firma ausente")

    body_bytes = await request.body()
    expected = hmac.new(
        LEXY_SHARED_SECRET.encode("utf-8"),
        body_bytes,
        hashlib.sha256,
    ).hexdigest()

    if not hmac.compare_digest(expected, signature):
        raise HTTPException(status_code=401, detail="Firma inválida")

    # 2. Parsear payload
    payload = await request.json()
    consulta_id = payload["consulta_id"]
    analysis = payload["analysis"]

    # 3. Idempotencia
    if consulta_id in consultas_procesadas:
        return JSONResponse({"received": True})
    consultas_procesadas.add(consulta_id)

    # 4. Procesar
    print(f"[Lexy] Consulta completada: {consulta_id}")
    print(f"[Lexy] Análisis: {analysis}")

    return JSONResponse({"received": True})

<?php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;

class LexyWebhookController extends Controller
{
    public function handle(Request $request): JsonResponse
    {
        // 1. Verificar firma
        $signature = $request->header('X-Lexy-Signature');
        if (!$signature) {
            return response()->json(['error' => 'Firma ausente'], 401);
        }

        $rawBody = $request->getContent();
        $expected = hash_hmac('sha256', $rawBody,
                              config('services.lexy.shared_secret'));

        if (!hash_equals($expected, $signature)) {
            return response()->json(['error' => 'Firma inválida'], 401);
        }

        // 2. Parsear payload
        $payload = $request->json()->all();
        $consultaId = $payload['consulta_id'];
        $analysis = $payload['analysis'];

        // 3. Idempotencia (cache de Laravel)
        $cacheKey = "lexy_webhook_{$consultaId}";
        if (cache()->has($cacheKey)) {
            return response()->json(['received' => true]);
        }
        cache()->put($cacheKey, true, now()->addDays(7));

        // 4. Procesar en background
        ProcessLexyAnalysis::dispatch($consultaId, $analysis);

        return response()->json(['received' => true]);
    }
}

<?php
namespace App\Services;

use Illuminate\Support\Facades\Http;

class LexyIngestService
{
    private string $apiKey;
    private string $baseUrl;
    private string $documentTypeId;

    public function __construct()
    {
        $this->apiKey = config('services.lexy.api_key');
        $this->baseUrl = config('services.lexy.base_url');
        $this->documentTypeId = config('services.lexy.document_type_id');
    }

    public function enviarDocumento(string $rutaArchivo): string
    {
        $response = Http::withToken($this->apiKey)
            ->timeout(30)
            ->attach('file', file_get_contents($rutaArchivo), basename($rutaArchivo))
            ->post("{$this->baseUrl}/api/ingest", [
                'document_type_id' => $this->documentTypeId,
            ]);

        if ($response->status() !== 202) {
            $error = $response->json('error', 'Error desconocido');
            throw new \RuntimeException("Error {$response->status()}: {$error}");
        }

        return $response->json('consulta_id');
    }
}