Acceder a la API

Cómo acceder a la API

Para realizar peticiones a la API en http://localhost:1337/api, es necesario configurar los permisos de acceso. Sigue estos pasos:

1. Dirígete a Settings (ícono de engranaje) > Users & Permissions plugin > Roles.
2. Selecciona el rol Public para habilitar el acceso público.
3. Configura los campos que deseas exponer en la API. Al hacerlo, se generarán automáticamente los endpoints correspondientes.

---

Peticiones GET

Por ejemplo, si tienes una colección llamada pelicula-pruebas, puedes acceder a sus datos con la siguiente URL:

http://localhost:1337/api/pelicula-pruebas

Respuesta esperada:

{
  "data": [
    {
      "id": 3,
      "documentId": "z50lykzud53l767plm9bnk5j",
      "name": "Pelicula 1",
      "description": [
        {
          "type": "paragraph",
          "children": [
            {
              "type": "text",
              "text": "Existen varias cosas."
            }
          ]
        }
      ],
      "publish": "2025-01-01",
      "createdAt": "2025-01-08T21:59:23.462Z",
      "updatedAt": "2025-01-08T22:53:44.050Z",
      "publishedAt": "2025-01-08T22:53:44.068Z"
    }
  ],
  "meta": {
    "pagination": {
      "page": 1,
      "pageSize": 25,
      "pageCount": 1,
      "total": 1
    }
  }
}

---

Obtener un recurso por id o documentId

Para obtener un recurso específico, puedes usar el id o un identificador único como el documentId. Ejemplo:

http://localhost:1337/api/pelicula-pruebas/o0ddp5tdqq2ie7pviwl2pagh

---

Relaciones, filtros y parámetros adicionales

Strapi permite extender las funcionalidades de sus endpoints mediante parámetros como:

• populate: Para incluir relaciones.
• filters: Para filtrar resultados.
• sort: Para ordenar datos.
• pagination: Para manejar datos paginados.

Ejemplo: Obtener una película con todas sus relaciones pobladas.

http://localhost:1337/api/pelicula-pruebas?populate=*

Más información: Documentación de parámetros en Strapi

---

Peticiones POST

Para crear un nuevo recurso, envía una solicitud similar a los datos obtenidos en una GET, respetando el formato de las relaciones.

URL:

http://localhost:1337/api/pelicula-pruebas

Ejemplo de cuerpo:

{
  "data": {
    "name": "Prueba 2",
    "description": [
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "text": "Hay varias cosas interesantes."
          }
        ]
      }
    ],
    "publish": "2025-02-02",
    "categorias": [
      "tl8215mwcqyc3glgn2ll7i0u"
    ]
  }
}

---

Peticiones PUT (Update)

Para actualizar un recurso, debes incluir el id en la URL y enviar únicamente los campos a modificar.

URL:

http://localhost:1337/api/pelicula-pruebas/:id

Ejemplo de cuerpo:

{
  "data": {
    "name": "Título actualizado"
  }
}

---

Peticiones DELETE

Para eliminar un recurso, basta con incluir su id en la URL:

http://localhost:1337/api/pelicula-pruebas/:id

---

Aquí tienes una versión mejorada y complementada de tu información:

---

Middlewares y Validaciones Personalizadas

Lifecycles en Strapi

Los lifecycles son puntos de anclaje que Strapi ofrece para interceptar las solicitudes realizadas a las entidades antes o después de acciones como crear, actualizar, eliminar o encontrar datos. Estas funciones son útiles para realizar tareas como:

• Bloquear o validar campos antes de que se persistan los datos.
• Completar datos automáticamente antes de almacenar información.
• Ejecutar acciones como el envío de correos electrónicos o llamadas a APIs externas.

Uso de lifecycles.js

Para implementar lógica personalizada, crea un archivo lifecycles.js en la carpeta de tu modelo en:
src/api/{nombre-del-modelo}/content-types/{nombre-del-modelo}/lifecycles.js.

Por ejemplo, en este archivo puedes manejar eventos como beforeCreate, afterCreate, beforeUpdate y afterUpdate. A continuación, un ejemplo práctico:

const { errors: { ApplicationError } } = require('@strapi/utils');

module.exports = {
    async beforeCreate(event) {
        const { action, params: { data } } = event;
        console.log("Antes de crear:", action, data);

        // Ejemplo: Validar un campo
        if (!data.email) {
            throw new ApplicationError("El campo 'email' es obligatorio.");
        }
    },

    async afterCreate(event) {
        const { result } = event;
        console.log("Después de crear:", result);
    },

    async beforeUpdate(event) {
        const { action, params: { data } } = event;
        console.log("Antes de actualizar:", action, data);

        // Llamada a una API externa para complementar datos
        const number = Math.floor(Math.random() * 20) + 1;
        try {
            const response = await fetch(`https://rickandmortyapi.com/api/character/${number}`);
            if (!response.ok) {
                throw new ApplicationError(`Error al obtener el personaje: ${response.statusText}`);
            }
            const character = await response.json();
            data.characterInfo = character; // Guardar datos en el campo correspondiente
        } catch (error) {
            console.error("Error al realizar la solicitud:", error);
        }
    },

    async afterUpdate(event) {
        const { result } = event;
        console.log("Después de actualizar:", result);
    },
};

Ventajas de los Lifecycles

• Flexibilidad: Permiten realizar tareas específicas según tus necesidades, como validar o transformar datos dinámicamente.
• Integración: Facilitan la comunicación con servicios externos como APIs o bases de datos.
• Automatización: Puedes configurar acciones automáticas, como enviar correos o notificaciones después de un evento.

Ejemplo Práctico

1. Validación Personalizada: Bloquear una creación si no cumple con un requisito.
2. Llamadas a APIs Externas: Enriquecer datos automáticamente con información de otras fuentes, como en el ejemplo de la API de Rick and Morty.
3. Auditoría: Registrar información de auditoría antes y después de las operaciones.

Recursos Adicionales

• Cómo usar hooks en Strapi
• Documentación oficial de lifecycles
• Models y lifecycles

Notas

• Recuerda que las funciones dentro de los lifecycles son asincrónicas. Asegúrate de manejar los errores adecuadamente usando try...catch.
• Evita realizar operaciones muy largas en los hooks, ya que pueden impactar en el rendimiento general de la API.

Aquí tienes tu información mejorada y complementada con explicaciones más claras, estructura organizada y algunos ejemplos adicionales para facilitar la comprensión:

---

Controladores y Servicios en Strapi

¿Qué son?

En Strapi, controladores y servicios son componentes clave para personalizar la lógica del backend.

• Controladores: Gestionan las solicitudes HTTP y permiten personalizar la lógica antes de enviar una respuesta. Son útiles para procesar peticiones que llegan desde la API pública.
• Servicios: Son responsables de manejar la lógica de negocio, separando el procesamiento complejo de los controladores. Esto ayuda a mantener el código más limpio, reutilizable y fácil de probar.

---

Controladores

Definición
Un controlador es un módulo que gestiona las solicitudes entrantes y prepara las respuestas. Solo son funcionales cuando las solicitudes provienen de la API pública, no desde el panel administrativo de Strapi. Permiten aplicar lógica personalizada antes de enviar la respuesta al cliente.

Documentación oficial: Controladores en Strapi

Ejemplo de implementación

El siguiente ejemplo muestra cómo personalizar un controlador para agregar lógica personalizada:

'use strict';

const { createCoreController } = require('@strapi/strapi').factories;

module.exports = createCoreController('api::endpoinst.endpoinst', ({ strapi }) => ({
    // Método personalizado
    async exampleAction(ctx) {
        try {
            const result = await strapi.plugins["email"].services.email.send({
                from: "elmer.swift17@ethereal.email",
                to: "luis.ocampo@inmersys.com",
                subject: "Hello World",
                html: `<p>Hola</p>`,
            });

            console.log('Email enviado:', result);
            ctx.body = 'Email enviado con éxito.';
        } catch (err) {
            console.error('Error al enviar email:', err);
            ctx.body = err;
        }
    },

    // Personalizando el método "find"
    async find(ctx) {
        // Añadir lógica personalizada a la consulta
        ctx.query = { ...ctx.query, local: 'en' };
        console.log('Consulta personalizada ejecutada.');

        // Llamar al método predeterminado de Strapi
        const { data, meta } = await super.find(ctx);

        // Modificar la respuesta
        meta.timestamp = Date.now();

        return { data, meta };
    },
}));

---

Cómo agregar un controlador personalizado con rutas

1. Crear un archivo de rutas: En la carpeta [tabla]/routes/, crea un archivo llamado custom.js.

2. Definir la ruta: El archivo debe incluir la configuración de la ruta que apunta al método personalizado del controlador.

   module.exports = {
       routes: [
           {
               method: 'GET',
               path: '/custom',
               handler: 'endpoinst.exampleAction',
               config: {
                   auth: false, // Opcional: Define si se requiere autenticación
               },
           },
       ],
   };

3. Hacer la petición:
   Para probar esta ruta personalizada, realiza una solicitud a:
   http://localhost:1337/api/custom
   Esto ejecutará el método exampleAction del controlador.

---

Servicios

Definición
Un servicio es un módulo en el que se centraliza la lógica de negocio. Permite reutilizar funciones y mantener el código más organizado y modular.

Documentación oficial: Servicios en Strapi

Ejemplo de implementación

Un servicio personalizado puede implementarse de la siguiente manera:

'use strict';

const { createCoreService } = require('@strapi/strapi').factories;

module.exports = createCoreService('api::endpoinst.endpoinst', ({ strapi }) => ({
    // Método personalizado
    async customService() {
        console.log('Ejecutando servicio personalizado...');
        // Lógica adicional aquí
        return 'Resultado del servicio';
    },
}));

---

Cómo usar un servicio personalizado en un controlador

Para usar un servicio desde un controlador, se puede llamar de esta manera:

async find(ctx) {
    // Llamar al servicio personalizado
    const resultado = await strapi.service('api::endpoinst.endpoinst').customService();
    console.log('Resultado del servicio:', resultado);

    // Lógica adicional del controlador
    ctx.query = { ...ctx.query, local: 'en' };
    console.log('Consulta personalizada ejecutada.');

    // Llamar al método predeterminado
    const { data, meta } = await super.find(ctx);

    // Modificar la respuesta
    meta.timestamp = Date.now();

    return { data, meta };
}

---

Comparación: Controladores vs. Servicios

Característica	Controladores	Servicios
Propósito	Gestionar solicitudes y respuestas de la API	Manejar la lógica de negocio
Ubicación	[tabla]/controllers/	[tabla]/services/
Reutilización	Limitada a las rutas que llaman al controlador	Reutilizable en múltiples controladores
Ejemplo de uso	Validar entradas o modificar datos antes de responder	Consultas complejas o cálculos avanzados