Generar mock.json con ChatGPT

Introducción

Puedes generar fácilmente un archivo mock.json compatible con Dynamic Mock utilizando ChatGPT y un documento OpenAPI (Swagger). Esta guía te muestra cómo hacerlo paso a paso.

Paso 1: Entiende el esquema de mock.json

Dynamic Mock utiliza un formato JSON específico para definir tus mocks. Este es el esquema que debes seguir:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Mock Schema",
  "type": "object",
  "properties": {
    "$schema": {
      "type": "string"
    },
    "extends": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "mocks": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "method": {
            "type": "string",
            "enum": [
              "GET",
              "POST",
              "PUT",
              "DELETE",
              "PATCH",
              "OPTIONS",
              "HEAD"
            ]
          },
          "path": {
            "type": "string"
          },
          "responses": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "in": {
                  "type": "string",
                  "enum": [
                    "body",
                    "query",
                    "param"
                  ]
                },
                "status": {
                  "oneOf": [
                    {
                      "type": "integer",
                      "minimum": 0,
                      "maximum": 600
                    },
                    {
                      "type": "string",
                      "pattern": "^(?:[0-9]|[1-5][0-9]{1,2}|600)$"
                    }
                  ]
                },
                "where": {
                  "type": "object",
                  "additionalProperties": true
                },
                "response": {
                  "type": "object",
                  "additionalProperties": true
                }
              },
              "required": [
                "response"
              ],
              "dependencies": {
                "where": [
                  "in"
                ]
              },
              "additionalProperties": false
            }
          }
        },
        "required": [
          "method",
          "path",
          "responses"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "mocks"
  ],
  "additionalProperties": false
}

Paso 2: Ejemplo de documento OpenAPI

A continuación se muestra un ejemplo simplificado de un documento OpenAPI que podemos usar como base:

openapi: 3.0.0
info:
  title: API de Ejemplo
  version: 1.0.0
paths:
  /users:
    get:
      summary: Obtener lista de usuarios
      responses:
        '200':
          description: Lista de usuarios
          content:
            application/json:
              schema:
                type: object
                properties:
                  users:
                    type: array
                    items:
                      type: object
                      properties:
                        id:
                          type: integer
                        name:
                          type: string
                        email:
                          type: string
    post:
      summary: Crear un nuevo usuario
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                name:
                  type: string
                email:
                  type: string
      responses:
        '201':
          description: Usuario creado exitosamente
          content:
            application/json:
              schema:
                type: object
                properties:
                  id:
                    type: integer
                  name:
                    type: string
                  email:
                    type: string
                  created_at:
                    type: string
                    format: date-time
        '400':
          description: Datos inválidos
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
  /users/{id}:
    get:
      summary: Obtener un usuario por ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer
      responses:
        '200':
          description: Detalles del usuario
          content:
            application/json:
              schema:
                type: object
                properties:
                  id:
                    type: integer
                  name:
                    type: string
                  email:
                    type: string
                  created_at:
                    type: string
                    format: date-time
        '404':
          description: Usuario no encontrado
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string

Paso 3: Prompt para ChatGPT

Copia y pega el siguiente prompt en ChatGPT, reemplazando la especificación OpenAPI de ejemplo con la tuya:

Prompt para ChatGPT:

Por favor, genera un archivo mock.json para Dynamic Mock basado en esta especificación OpenAPI. El archivo debe seguir este esquema: { "$schema": "./mock.schema.json", "mocks": [ { "method": "MÉTODO_HTTP", // GET, POST, PUT, DELETE, etc. "path": "/ruta/del/endpoint", // Ruta del endpoint, puede incluir parámetros como /:id "responses": [ { "in": "body|query|param", // Donde buscar la condición: body (cuerpo), query (parámetros URL), param (parámetros de ruta) "where": { // Condiciones para esta respuesta }, "status": 200, // Código de estado HTTP "response": { // Objeto JSON con los datos de respuesta } }, // Puedes tener múltiples respuestas con diferentes condiciones { "response": { // Respuesta por defecto si no se cumple ninguna condición } } ] } ] } Para cada endpoint en la especificación OpenAPI: 1. Crea una entrada en "mocks" con el método HTTP correcto 2. Usa la ruta del endpoint 3. Para cada posible respuesta en la especificación: - Crea una entrada en "responses" - Genera datos ficticios que cumplan con el esquema - Incluye diferentes casos con condiciones "where" para mostrar varios escenarios - Incluye una respuesta por defecto Aquí está la especificación OpenAPI: [PEGA TU ESPECIFICACIÓN OPENAPI AQUÍ]

Paso 4: Ejemplo de resultado

Basado en la especificación OpenAPI de ejemplo, este es el tipo de archivo mock.json que ChatGPT generaría:


  "$schema": "./mock.schema.json",
  "mocks": [
    {
      "method": "GET",
      "path": "/users",
      "responses": [
        {
          "in": "query",
          "where": {
            "limit": 5
          },
          "status": 200,
          "response": {
            "users": [
              {
                "id": 1,
                "name": "John Doe",
                "email": "john@example.com"
              },
              {
                "id": 2,
                "name": "Jane Smith",
                "email": "jane@example.com"
              },
              {
                "id": 3,
                "name": "Alice Johnson",
                "email": "alice@example.com"
              },
              {
                "id": 4,
                "name": "Bob Brown",
                "email": "bob@example.com"
              },
              {
                "id": 5,
                "name": "Charlie Davis",
                "email": "charlie@example.com"
              }
            ]
          }
        },
        {
          "response": {
            "users": [
              {
                "id": 1,
                "name": "John Doe",
                "email": "john@example.com"
              },
              {
                "id": 2,
                "name": "Jane Smith",
                "email": "jane@example.com"
              },
              {
                "id": 3,
                "name": "Alice Johnson",
                "email": "alice@example.com"
              },
              {
                "id": 4,
                "name": "Bob Brown",
                "email": "bob@example.com"
              },
              {
                "id": 5,
                "name": "Charlie Davis",
                "email": "charlie@example.com"
              },
              {
                "id": 6,
                "name": "Dave Wilson",
                "email": "dave@example.com"
              },
              {
                "id": 7,
                "name": "Eve Martinez",
                "email": "eve@example.com"
              },
              {
                "id": 8,
                "name": "Frank Lopez",
                "email": "frank@example.com"
              },
              {
                "id": 9,
                "name": "Grace Lee",
                "email": "grace@example.com"
              },
              {
                "id": 10,
                "name": "Harry Kim",
                "email": "harry@example.com"
              }
            ]
          }
        }
      ]
    },
    {
      "method": "POST",
      "path": "/users",
      "responses": [
        {
          "in": "body",
          "where": {
            "name": "New User",
            "email": "newuser@example.com"
          },
          "status": 201,
          "response": {
            "id": 11,
            "name": "New User",
            "email": "newuser@example.com",
            "created_at": "2025-07-03T15:30:45Z"
          }
        },
        {
          "in": "body",
          "where": {
            "email": "invalid"
          },
          "status": 400,
          "response": {
            "error": "Email format is invalid"
          }
        },
        {
          "status": 201,
          "response": {
            "id": 12,
            "name": "Generic User",
            "email": "user@example.com",
            "created_at": "2025-07-03T15:35:22Z"
          }
        }
      ]
    },
    {
      "method": "GET",
      "path": "/users/:id",
      "responses": [
        {
          "in": "param",
          "where": {
            "id": "1"
          },
          "status": 200,
          "response": {
            "id": 1,
            "name": "John Doe",
            "email": "john@example.com",
            "created_at": "2025-01-15T10:30:00Z"
          }
        },
        {
          "in": "param",
          "where": {
            "id": "2"
          },
          "status": 200,
          "response": {
            "id": 2,
            "name": "Jane Smith",
            "email": "jane@example.com",
            "created_at": "2025-02-20T14:15:30Z"
          }
        },
        {
          "in": "param",
          "where": {
            "id": "999"
          },
          "status": 404,
          "response": {
            "error": "User not found"
          }
        },
        {
          "status": 404,
          "response": {
            "error": "User not found"
          }
        }
      ]
    }
  ]

Paso 5: Usa tu archivo mock.json

Una vez que tengas tu archivo mock.json generado por ChatGPT:

  1. Copia el contenido y guárdalo como mock.json en tu proyecto
  2. Colócalo en el directorio correcto de tu proyecto (generalmente en /public)
  3. Inicia Dynamic Mock con yarn dev
  4. Prueba tus endpoints en la página de Playground

Recuerda que puedes editar manualmente el archivo mock.json para añadir más escenarios o ajustar las respuestas según sea necesario.

Consejos adicionales

  • Puedes proporcionar ejemplos más específicos a ChatGPT si quieres tipos de datos particulares en tus respuestas
  • Para APIs más complejas, considera dividir el proceso y generar mock.json por secciones
  • Revisa siempre el resultado generado y ajústalo según sea necesario
  • Usa la validación del esquema para asegurarte de que tu mock.json es válido