sto realizzando un applicazione con angular e mysql. ho questo file: user.model.js 
const sql = require("./db.js");
const Utility = require("../controllers/utility.controller.js");
const passwordConfig = require("../config/password.config");


const InfoUser = function(dati) {
    this.idUtente = dati.idUtente;
    this.passwordUtente=dati.passwordUtente;
    this.passwordNuova=dati.passwordNuova;
};

InfoUser.checkPswUser=(utente,result)=>{
  sql.query(`select passwordUtente from utente
            where utente.id=${utente.idUtente} and passwordUtente=aes_encrypt("${utente.passwordUtente}","${passwordConfig.KEY}")`, (err, res) => {
      if (err) {
        console.log("error: ", err);
        result(err, null);
        return;
      } 

      if(JSON.parse(JSON.stringify(res)).length>0)
        result(null, {status:200});
      else
        result(null, {status:500});
      
  }); 
}

InfoUser.getInfoAccount=(idUtente,result)=>{
  sql.query(`select username,email,nome,cognome,dataNascita,comuneNascita,
              provinciaNascita,capNascita,sesso,cellulare,via,numCivico,cap,provincia,comune 
              from utente inner join residenza on utente.id=residenza.idUtente
              inner join anagrafica on utente.id=anagrafica.idUtente
              where utente.id=${idUtente}`, (err, res) => {
    if (err) {
      console.log("error: ", err);
      result(err, null);
      return;
    }
    result(null, res);
  }); 
}

InfoUser.updateUser=(dati,idUtente,result)=>{

  if(dati.utente.passwordNuova!=null && dati.utente.passwordNuova!='' && dati.utente.passwordNuova!=dati.utente.passwordUtente)
    query=`update utente set username= "${dati.utente.username}" , passwordUtente= aes_encrypt("${dati.utente.passwordNuova}","${passwordConfig.KEY}") , email= "${dati.utente.email}" ,cellulare='${dati.utente.cellulare}' where id = ${idUtente}`;
  else if(dati.utente.passwordNuova==null)
    query=`update utente set username= "${dati.utente.username}" , email= "${dati.utente.email}" ,cellulare='${dati.utente.cellulare}' where id = ${idUtente}`;
  
  sql.query(query,(err, res) => {
    if (err) {
      console.log("error: ", err);
      result(err, null);
      return;
    }

    result(null, res);
  });
}

InfoUser.getAllUsers = (req, res) => {
  const query = `
    SELECT a.nome, a.cognome, u.email, a.cellulare
    FROM utente AS u
    JOIN anagrafica AS a ON u.id = a.idUtente
  `;

  sql.query(query, (error, results) => {
    if (error) {
      console.error(error);
      res.status(500).json({ message: 'Errore durante la ricerca degli utenti.' });
    } else {
      console.log(results);
      res.json(results);
    }
  });
};

InfoUser.update=async (body,result)=>{
  var risultato= await Utility.isExist(null,body.email,null);
  var risultatoToken=await Utility.verifyTokenForEmail(body.token);
  let query;

  if(risultato.length>0 && risultatoToken.email!=undefined){
    if(body.flag!=1)
      query=`UPDATE utente set utenzaAttiva="${body.utenzaAttiva}" where email="${body.email}"`;
    else
      query=`UPDATE utente set passwordUtente=aes_encrypt('${body.passwordUtente}',"${passwordConfig.KEY}") where email="${body.email}"`;
      
    sql.query(query,(err, res) => {
      if (err) {
        console.log("error: ", err);
        err.status=500;
        result(err, null);
      }

      if(body.flag!=1)
        res.message="Utenza aggiornata con successo";
      else
        res.message="Password ripristinata con successo";

      result(null,res);
    }); 
  }
  else{
    if(risultatoToken.email==undefined)
      result({status:403,message:'link scaduto ripetere la procedura per avere un nuovo link'});
    else
      result({status:500,message:"Utenza non trovata"});
  }
}
  
module.exports = InfoUser;


Ho questo altro file user.controller.js 
const Utility = require("../controllers/utility.controller.js");
const User = require("../models/user.model.js");
const Utenza = require("../models/creaUtenza.model.js");
const Residenza = require("../models/residenza.model.js");
const Anagrafica = require("../models/creaAnagrafica.model.js");

exports.getInfoAccount=async (req,res)=>{

    const utente = new User({
        idUtente: await Utility.getIdUtente(req)
    });

    User.getInfoAccount(utente.idUtente,(err, data) => {
        if (err)
            res.status(500).send({message:err.message});
        else{ 
            res.send(data);
        }
    });
}

exports.getAllUsers = (req, res) => {
    User.getAllUsers((err, data) => {
      if (err) {
        res.status(500).json({ message: err.message });
      } else {
        console.log(res);
        res.json(data);
      }
    });
  };
  

exports.checkPswUtente=async (req,res)=>{

    const utente = new User({
        idUtente: await Utility.getIdUtente(req),
        passwordUtente:req.body.passwordUtente
    });

    if (!req.body) {
        result.status(400).send({
          message: "Content can not be empty!"
        });
    }

    User.checkPswUser(utente,(err, data) => {
        if (err)
            res.status(500).send({message:err.message});
        else{ 
            res.send(data);
        }
    });
}

/**
 * crea una nuova utenza se non è già esistente
 * 
 * @param {*} req parametri richiesti
 * @param {*} res risposta del be
 */
exports.create = async (req,res) => {
    // Validate request
    if (!req.body)
      res.status(400).send({ message: "Content can not be empty!"});
    let dati=req.body;

    let isExist=await Utility.isExist(null,dati.email,null);

    if(isExist.length==0){
        const utenza = new Utenza(dati);

        Utenza.create(utenza,async (err, data) => {
            if (err)
                res.status(500).send({ message: err.message || "Some error occurred while creating the user."});
            else {
                await createAnagrafica(dati,data.insertId);
                let risp=await createResidenza(dati,data.insertId);
                let token = await Utility.createToken({email:utenza.email},'3h');

                let subject='Grazie per esserti registrato alla Fattoria Madonna della Querce';
                let html=`
                        <h1>Benvenuto ${utenza.email},</h1> <br> 
                        <a style="color:blue" href="http://localhost:4200/#/confermaEmail/${utenza.email}/${token}">
                        clicca qua per confermare la tua email.</a> <br><br> <b>Attenzione il link è valido per 3 ore.</b>`;
                let rispEmail=await Utility.sendMail(subject,html,utenza.email);
                
                if(rispEmail)
                    risp.message="Controlla la posta per conferma la creazione dell'account";
                    
                res.send(risp);
            }
        });
    }
    else{
      res.status(500).send({message:"Utenza già esistente"});
    }
};

function createAnagrafica(dati,id){
    const anagrafica= new Anagrafica(dati);

    return new Promise(resolve =>{
        Anagrafica.create(id,anagrafica,(err,data)=>{
            if (err)
                res.status(500).send({
                message:err.message || "Some error occurred while creating the user."
                });
            else
              resolve(data);
        })
    });
}

function updateAnagrafica(dati,idUtente){
    const anagrafica= new Anagrafica(dati);

    return new Promise(resolve =>{
        Anagrafica.update(idUtente,anagrafica,(err,data)=>{
            if (err)
                res.status(500).send({
                message:err.message || "Some error occurred while update the user."
                });
            else
              resolve(data);
        })
    });
}

function createResidenza(dati,id){
    const residenza = new Residenza(dati);

    return new Promise(resolve =>{
        Residenza.create(id,residenza, (err, data) => {
            if (err)
                res.status(500).send({
                    message:
                    err.message || "Some error occurred while creating the user."
                });
            else{
                resolve(data);
            }
        });
    });
}

function updateResidenza(dati,idUtente){
    const residenza = new Residenza(dati);

    return new Promise(resolve =>{
        Residenza.update(idUtente,residenza,(err, data) => {
            if (err)
                res.status(500).send({
                    message:
                    err.message || "Some error occurred while update the user."
                });
            else{
                resolve(data);
            }
        });
    });
}

exports.ripristinaPassword=async (req,result)=>{

    let risp=await Utility.isExist(null,req.body.email,null);
   
    if(risp.length>0){
        let risp=await Utility.isActiveUser(null,req.body.email);

        if(risp.status==200){
            let subject='Riempostare password';
            let token = await Utility.createToken({email:req.body.email},'3h');
            let html=`<h1>Gentile ${req.body.email},</h1> <br> <a style="color:blue" href="http://localhost:4200/#/ripristinaPassword/${req.body.email}/${token}">clicca qua per ripristinare la password.</a> <br><br> <b>Attenzione il link è valido per 3 ore.</b>`
            let risposta=await Utility.sendMail(subject,html,req.body.email);
            
            if(risposta)
                result.send({message:"Controlla la posta per conferma la creazione dell'account"});
            else
                result.send(risposta);
        }
        else
            result.status(500).send({message:risp.message});
        
    }
    else
        result.status(500).send({message:"Utenza non trovata"});
}

/**
 * per attivare l'utenza/ modificare la password
 * @param {*} req dati richiesti
 * @param {*} result risultato query
 */
exports.update=async (req,result)=>{
    if (!req.body) {
      result.status(400).send({
        message: "Content can not be empty!"
      });
    }
  
    User.update(req.body,(err, data) => {
        if (err)
            result.status(err.status).send({message:err.message});
        else
            result.send(data);
    });
}

exports.updateInfoUser= async (req,res)=>{
     
    if (!req.body)
        res.status(400).send({ message: "Content can not be empty!"});


    let idUtente = await Utility.getIdUtente(req);
   
    let dati=JSON.parse(req.body.dati);

    User.updateUser(dati, idUtente,(err, data) => {
        if (err)
            res.status(500).send({message:err.message});
        else{ 
            updateAnagrafica(dati.anagrafica,idUtente);
            updateResidenza(dati.residenza,idUtente);
            data.message = "informazioni utente aggiornate con successo";
            res.send(data);
        }
    });
}

Ho questo file route.js 
const express = require('express');
const router = express.Router();
const path = require('path');

// parse requests of content-type - application/json
router.use(express.json());

// parse requests of content-type - application/x-www-form-urlencoded
router.use(express.urlencoded({ extended: true }));

const login = require("../controllers/login.controller");
const utente = require("../controllers/user.controller");
const utility = require("../controllers/utility.controller");

router.get("*",utility.verifyToken);
router.post("*",utility.verifyToken);
router.put("*",utility.verifyToken);
router.delete("*",utility.verifyToken);


router.post("/api/auth/createUtenza.json", utente.create); 
router.post("/api/auth/aggiornaUtenza.json", utente.update); 
router.post("/api/auth/ripristinaPassword.json", utente.ripristinaPassword); 
router.post("/api/auth/login.json",login.login); 


router.get("/api/getInfoUser.json",utente.getInfoAccount);
router.put("/api/updateDatiUtente.json", utente.updateInfoUser);
router.post("/api/checkPsw.json", utente.checkPswUtente);


// Definisci la route per ottenere tutti gli utenti
router.get("/api/getAllUsers.json", utente.getAllUsers);

module.exports = router;

e infinde admindashboardcomponent
import { Component, OnInit } from '@angular/core';
import { HttpClient } from '@angular/common/http';
@Component({
  selector: 'app-admin-dashboard',
  templateUrl: './admin-dashboard.component.html',
  styleUrls: ['./admin-dashboard.component.css'],
})
export class AdminDashboardComponent implements OnInit {
  users: any[] = [];

  constructor(private http: HttpClient) { }

  ngOnInit(): void {
    this.getUsers();
  }

  getUsers(): void {
  this.http.get<any[]>('/api/getAllUsers.json')
    .subscribe(
      users => {
        // Assegna la lista degli utenti alla proprietà "users" del tuo componente
        this.users = users;
      },
      error => {
        console.log('Error retrieving users:', error);
      }
    );
}
}

Il problema è che quando provo a usare la funzione getUsers() il console.log mi restituisce [
  RowDataPacket {
    nome: 'Lorenzo',
    cognome: 'Paolucci',
    email: 'lorenzo.paolucci@studenti.unicam.it',
    cellulare: 333
  }
]
e poi ho questo errore: ]
C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\Parser.js:437
      throw err; // Rethrow non-MySQL errors
      ^

TypeError: Cannot read properties of undefined (reading 'json')
    at Query.<anonymous> (C:\Users\jacom\Documents\PiggyFarmWeb\backend\models\user.model.js:75:11)
    at Query.<anonymous> (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\Connection.js:526:10)
    at Query._callback (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\Connection.js:488:16)
    at Sequence.end (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\sequences\Sequence.js:83:24)      
    at Query._handleFinalResultPacket (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\sequences\Query.js:149:8)
    at Query.EofPacket (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\sequences\Query.js:133:8)      
    at Protocol._parsePacket (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\Protocol.js:291:23)      
    at Parser._parsePacket (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\Parser.js:433:10)
    at Parser.write (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\Parser.js:43:10)
    at Protocol.write (C:\Users\jacom\Documents\PiggyFarmWeb\backend\node_modules\mysql\lib\protocol\Protocol.js:38:16)