Como crear rápidamente APIs RESTful con Xojo

A continuación encontrarás traducido al Castellano el artículo escrito originalmente por Gabriel Ludosanu y publicado en el Blog oficial de Xojo.

Las Interfaces de Programación de Aplicación (APIs, en sus singlas en inglés) son esenciales a la hora de realizar interacciones digitales. Estas facilitan la comunicación y la capacidad de compartir datos entre diferentes sistemas, suponiendo así el núcleo de muchas aplicaciones y servicios.

Este artículo examina las capacidades de Xojo a la hora de crear un sencillo servicio web basado en API. Aprenderás como utilizar los diferentes métodos HTTP, las peticiones y enviar respuestas. La simplicidad de Xojo hace que suponga una opción excelente tanto para los desarrolladores experimentados provenientes de otros lenguajes, como también para aquellos familiarizados con su lenguaje fácil de usar.

Los fundamentos: la función HandleURL

En el corazón de cada servicio API web desarrollado con Xojo se encuentra la función HandleURL, incluida en la clase App. Esta es la responsable de gestionar el ciclo de petición-respuesta. Recibe las peticiones web entrantes (WebRequest), las procesa basándose en sus características y genera las respuestas apropiadas (WebResponse) que se enviarán de vuelta.

Definir los puntos de entrada API para Peticiones GET

Las peticiones GET se utilizan principalmente para obtener datos. Para gestionar estas peticiones de forma eficaz, veamos en el siguiente código de ejemplo cómo definir los puntos de entrada de una API que se corresponda con datos o acciones específicas.

If request.Method = "GET" Then
  Select Case request.Path
  Case "time"
    Var currentTime As String = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
    response.Write("{""message"": """ + currentTime + """}")
    response.Status = 200
    Return True
  Case "hello"
    response.Write("{""message"": ""Hola, Mundo!""}")
    response.Status = 200
    Return True
  End Select
End If

Aquí definimos dos puntos de entrada: /time y /hello.

Una petición GET a /time devolverá la fecha y hora actuales en formato JSON, mientras que una petición a /hello devolverá el amigable saludo “¡Hola, Mundo!”

La propiedad response.Status se define a 200, indicando así una respuesta exitosa. Obtén más información sobre los códigos de estado HTTP.

Definir los puntos de entrada API para peticiones POST

Mientras que las peticiones GET se utilizan principalmente para obtener datos, las peticiones POST se emplean para enviar datos de modo que puedan ser procesados por la API. Pongamos por caso el envío de un formulario (estás enviando datos al servidor mediante la petición POST).

If request.Method = "POST" Then
  Select Case request.Path
  Case "some-data"
    Try
      Var jReceivedData As New JSONItem(request.Body)
      Response.Write(jReceivedData.ToString)
      Response.Status = 200
      Return True
    Catch e As JSONException
      response.Write("{""error"": ""Internal Server Error""}")
      response.Status = 500
      Return True
    End Try
  End Select
End If

En este ejemplo, la petición POST al punto de entrada /some-data espera recibir datos en formato JSON (request.Body) para su procesamiento.

Si se pueden parsear correctamente los datos, la API responde con los datos recibidos; de lo contrario se devuelve el estado y mensaje de error al cliente que realizó la petición.

¡Todo junto!

Ahora que sabemos como gestionar las peticiones “GET” y “POST”, puedes comenzar a crear APIs más complejas con diferentes puntos de entrada disponibles para cada uno de estos métodos. Para ilustrar más en detalle el desarrollo de los puntos de entrada de una API, consideremos el siguiente código de ejemplo que utilizarse como plantilla:

Function HandleURL(request As WebRequest, response As WebResponse) Handles HandleURL as Boolean
  response.MIMEType = "application/json"
  
  Try
    Select Case request.Method
    Case "GET"
      
      Select Case request.Path
      Case "time"
        Var currentTime As String = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
        response.Write("{""message"": """ + currentTime + """}")
        response.Status = 200
        Return True
      Case "hello"
        response.Write("{""message"": ""Hello, World!""}")
        response.Status = 200
        Return True
      Else
        response.Write("{""error"": ""Not Found""}")
        response.Status = 404
        Return True
      End Select
      
    Case "POST"
      
      Select Case request.Path
      Case "some-data"
        Try
          Var jReceivedData As New JSONItem(request.Body)
          Response.Write(jReceivedData.ToString)
          Response.Status = 200
          Return True
        Catch e As JSONException
          response.Write("{""error"": ""Internal Server Error""}")
          response.Status = 500
          Return True
        End Try
      Else
        response.Write("{""error"": ""Not Found""}")
        response.Status = 404
        Return True
      End Select
      
    End Select
    
  Catch e As RuntimeException
    response.Write("{""error"": ""Internal Server Error""}")
    response.Status = 500
    Return True
  End Try
  
  response.Write("{""error"": ""Not Found""}")
  response.Status = 404
  Return True
  
End Function

Nota: Observa la línea inicial en la función HandleURL

response.MIMEType = "application/json"

Esta línea de código indica al cliente (navegador o aplicación) que el servicio API responde utilizando el formato JSON. Definir el MIMEType como “application/json” es lo más recomendable y previene cualquier error potencial de procesamiento en el lado del cliente.

Siguientes pasos

Puedes advertir que parte del código está repetido (pista: las respuestas de error), de modo que sería una buena idea crear algún método de ayuda que tratase con este tipo de código en particular para evitar la repetición de código. Además, considera mover el código de la función HandleURL a un método independiente que se invoque desde la función HandleURL para mejorar la organización del código.

También puedes leer el artículo sobre microservicios y su propósito para obtener más información sobre el tipo de APIs que puedes crear.