Cómo almacenar la información del agente y reportar el agente conectado

Hola amigos!, alguien sabe a que se debe este error:

Este es mi código:

'use strict'

const debug = require('debug')('platziverse:mqtt')
const mosca = require('mosca')
// const redis = require('redis')
const mongo = require('mongoose')
const chalk = require('chalk')
const db = require('platziverse-db')
const { configuration } = require('platziverse-utils')
const { parsePayload } = require('./utils')

// const backend = {
//   type: 'redis',
//   redis,
//   return_buffers: true
// }
const backend = {
  type: 'mongoose',
  url: 'mongodb+srv://db_user_platzinodejs:[email protected]/test2?retryWrites=true&w=majority',
  // redis,
  mongo,
  return_buffers: true
}

const settings = {
  port: 1883,
  backend
}

const config = configuration(false) // El setup es falso //Revisar el módulo platziverse-utils

const server = new mosca.Server(settings)
const clients = new Map() // El objeto Map almacena pares clave/valor. Cualquier valor (tanto objetos como valores primitivos) pueden ser usados como clave o valor.

let Agent, Metric

server.on('clientConnected', client => {
  debug(`Client Connected: ${client.id}`)
  clients.set(client.id, null)
})

server.on('clientDisconnected', async client => {
  debug(`Client Disconnected: ${client.id}`)
  const agent = clients.get(client.id)

  if (agent) {
    agent.connected = false // Mark agent as disconnected (Marcar agente como desconectado)
  }

  try {
    await Agent.createOrUpdate(agent)
  } catch (e) {
    return handleError(e)
  }

  clients.delete(client.id)

  server.publish({
    topic: 'agent/disconnected',
    payload: JSON.stringify({
      agent: {
        uuid: agent.uuid
      }
    })
  })

  debug(`Clent (${client.id}) associated to Agent (${agent.uuid}) marked as disconnected`)
})

server.on('published', async (packet, client) => {
  debug(`Received: ${packet.topic}`) // 'topic' viene siendo el tipo de mensaje en este caso sería agent/connected, agent/disconnected

  switch (packet.topic) {
    case 'agent/connected':
    case 'agent/disconnected':
      debug(`Payload: ${packet.payload}`)
      break
    case 'agent/message':
      debug(`Payload: ${packet.payload}`)

      const payload = parsePayload(packet.payload)

      if (payload) {
        payload.agent.connected = true

        let agent
        try {
          agent = await Agent.createOrUpdate(payload.agent)
        } catch (e) { // Si llega un agente con mala información entonces me retorna un error
          return handleError(e)
        }

        debug(`Agent ${agent.uuid} saved`)

        // Notify Agent is connected
        if (!clients.get(client.id)) { // Vamos hacer un broadcast o notificar a todos los clientes que esten conectados en este evento o broker que un agente se conectó
          clients.set(client.id, agent)
          server.publish({
            topic: 'agent/connected',
            payload: JSON.stringify({
              agent: {
                uuid: agent.uuid,
                name: agent.name,
                username: agent.username,
                hostname: agent.hostname,
                pid: agent.pid,
                connected: agent.connected
              }
            })
          })
        }

        // Store Metrics
        for (const metric of payload.metrics) { // Me permite iterar sobre un arreglo y obtener cada uno de los objetos de ese arreglo
          let m // Dentro del for vamos hacer operaciones de async await para almacenar las metricas, es importante utilizar el forof que soporta el async await

          try {
            m = await Metric.create(agent.uuid, metric)
          } catch (error) {
            return handleError
          }
          debug(`Metric ${m.id} save on agent ${agent.uuid}`)
        }
      }
      break
  }

  // Esa informacion que va ser enviada va ha venir en el payload
})

server.on('ready', async () => {
  const services = await db(config).catch(handleFatalError) // Cuando el servidor esta listo yo instancio mi Base de Datos

  Agent = services.Agent
  Metric = services.Metric

  console.log(`${chalk.green('[platziverse-mqtt]')} server is running`)
  // console.log("Activo")
})

server.on('error', handleFatalError)

process.on('uncaughtException', handleFatalError)
process.on('unhandledRejection', handleFatalError)

function handleFatalError (err) {
  console.error(`${chalk.red('[fatal error]')} ${err.message}`) // Imprimimos el mensaje de error
  console.error(err.stack) // Imprimimos el tipo de error que esta ocurriendo
  process.exit(1) // Matamos el proceso retornando un código 1, que es un código de error
}

function handleError (err) {
  console.error(`${chalk.red('[error]')} ${err.message}`) // Imprimimos el mensaje de error
  console.error(err.stack) // Imprimimos el tipo de error que esta ocurriendo
  // process.exit(1) // Matamos el proceso retornando un código 1, que es un código de error
}

.
Saludos!

A ESLint no le gustan las declaraciones let dentro de los bloques de mayúsculas y minúsculas dentro de un reductor, ¿por qué?

Esto se desaconseja porque da como resultado que la variable esté dentro del alcance fuera de su actual case. Al usar un bloque, limita el alcance de la variable a ese bloque.

Use {}para crear el alcance del bloque con mayúsculas y minúsculas, como este:

case ‘agent/message’: {
…
}

Unexpected lexical declaration in case block.