Métodos No Seguros

# ===== POST - Crear Recurso (NO Idempotente) =====
# Cada petición crea un nuevo recurso
POST /api/orders HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123

{
  "product_id": 456,
  "quantity": 2,
  "shipping_address": "123 Main St"
}

# Respuesta
HTTP/1.1 201 Created
Location: /api/orders/789
Content-Type: application/json

{
  "id": 789,
  "product_id": 456,
  "quantity": 2,
  "total": 39.98,
  "status": "pending"
}

# Reintentar crea OTRO pedido (id: 790) - NO idempotente
# Solución: Usar cabecera Idempotency-Key

POST /api/orders HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123
Idempotency-Key: 550e8400-e29b-41d4-a716-446655440000

{
  "product_id": 456,
  "quantity": 2
}

# Reintentar con misma clave devuelve pedido original (id: 789) - AHORA idempotente

# ===== PUT - Reemplazar Recurso (Idempotente) =====
# Reemplaza recurso completo
PUT /api/products/456 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123

{
  "name": "Widget Actualizado",
  "price": 12.99,
  "stock": 150,
  "description": "Nueva descripción"
}

# Respuesta
HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": 456,
  "name": "Widget Actualizado",
  "price": 12.99,
  "stock": 150,
  "description": "Nueva descripción"
}

# Reintentar con mismos datos - recurso termina en mismo estado (idempotente)

# ===== PATCH - Actualización Parcial (Usualmente NO Idempotente) =====
# Actualiza solo campos especificados
PATCH /api/users/123 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Authorization: Bearer token123

{
  "email": "[email protected]"
}

# Respuesta
HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": 123,
  "name": "John Doe",
  "email": "[email protected]"
}

# Idempotente si se establecen valores absolutos
# NO idempotente si se usan operaciones como incremento:
PATCH /api/products/456 HTTP/1.1
Content-Type: application/json

{
  "stock": { "$inc": -1 }  # Decrementar en 1
}

# Reintentar decrementa nuevamente - ¡NO idempotente!

# ===== DELETE - Eliminar Recurso (Idempotente) =====
# Primera petición
DELETE /api/posts/789 HTTP/1.1
Host: api.example.com
Authorization: Bearer token123

# Respuesta
HTTP/1.1 204 No Content

# Reintentar - recurso ya eliminado
DELETE /api/posts/789 HTTP/1.1
Host: api.example.com
Authorization: Bearer token123

# Respuesta (puede ser 404 o 204, ambos aceptables)
HTTP/1.1 404 Not Found

# El resultado es el mismo: el recurso no existe (idempotente)

// Ejemplos en JavaScript de métodos no seguros

// ===== POST - Crear Recurso =====
async function createOrder(productId, quantity) {
  const response = await fetch('/api/orders', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      product_id: productId,
      quantity: quantity
    })
  });

  if (response.ok) {
    const order = await response.json();
    console.log('Pedido creado:', order.id);
    return order;
  }
  throw new Error('Falló la creación del pedido');
}

// Llamar dos veces crea DOS pedidos (no seguro de reintentar)
await createOrder(456, 2); // Crea pedido #789
await createOrder(456, 2); // Crea pedido #790 (¡duplicado!)

// POST con Clave de Idempotencia
async function createOrderSafely(productId, quantity, idempotencyKey) {
  const response = await fetch('/api/orders', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`,
      'Idempotency-Key': idempotencyKey
    },
    body: JSON.stringify({
      product_id: productId,
      quantity: quantity
    })
  });

  return response.json();
}

const key = crypto.randomUUID();
await createOrderSafely(456, 2, key); // Crea pedido #789
await createOrderSafely(456, 2, key); // Devuelve pedido #789 (el mismo)

// ===== PUT - Reemplazar Recurso =====
async function updateProduct(id, productData) {
  const response = await fetch(`/api/products/${id}`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify(productData)
  });

  return response.json();
}

// PUT es idempotente - seguro de reintentar
const product = {
  name: 'Widget Actualizado',
  price: 12.99,
  stock: 150
};

await updateProduct(456, product); // Producto actualizado
await updateProduct(456, product); // Mismo resultado (idempotente)

// ===== PATCH - Actualización Parcial =====
async function updateUserEmail(userId, newEmail) {
  const response = await fetch(`/api/users/${userId}`, {
    method: 'PATCH',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      email: newEmail
    })
  });

  return response.json();
}

// PATCH idempotente (valor absoluto)
await updateUserEmail(123, '[email protected]'); // Email cambiado
await updateUserEmail(123, '[email protected]'); // Email sigue siendo '[email protected]' (idempotente)

// PATCH no idempotente (operación de incremento)
async function incrementViewCount(postId) {
  const response = await fetch(`/api/posts/${postId}`, {
    method: 'PATCH',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      views: { $inc: 1 }
    })
  });

  return response.json();
}

await incrementViewCount(789); // Vistas: 101
await incrementViewCount(789); // Vistas: 102 (¡NO idempotente!)

// ===== DELETE - Eliminar Recurso =====
async function deletePost(postId) {
  const response = await fetch(`/api/posts/${postId}`, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${token}`
    }
  });

  if (response.status === 204 || response.status === 404) {
    console.log('Publicación eliminada o ya eliminada');
    return true;
  }
  throw new Error('Falló la eliminación de la publicación');
}

// DELETE es idempotente - seguro de reintentar
await deletePost(789); // 204 No Content (eliminado)
await deletePost(789); // 404 Not Found (ya eliminado)
// El resultado es el mismo: la publicación no existe

// ===== Manejo de Errores y Lógica de Reintento =====
async function safeRetry(operation, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      if (i === maxRetries - 1) throw error;

      // Backoff exponencial
      const delay = Math.pow(2, i) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// Seguro de reintentar operaciones idempotentes
await safeRetry(() => updateProduct(456, product)); // PUT - seguro
await safeRetry(() => deletePost(789));             // DELETE - seguro

// NO seguro de reintentar operaciones no idempotentes sin clave de idempotencia
// await safeRetry(() => createOrder(456, 2)); // ¡NO HAGAS ESTO - crea duplicados!

// Seguro con clave de idempotencia
const idempKey = crypto.randomUUID();
await safeRetry(() => createOrderSafely(456, 2, idempKey)); // Seguro ahora