NodeJS Promise then not executed - node.js

Question

I need some help. It's my first try with promises.
Here is my code for the promise:
const deleteUniversRefInTarget = (universName, targetName) => {
console.log('Appel de deleteUniversRefInTarget')
const promis = new Promise((resolve, reject) => {
Target.findOneAndUpdate({ univers: universName, name: targetName },
(err, target) => {
console.log('Entrée dans la promesse')
if (err) {
reject(err)
} else {
if (target === null) {
reject(TypeError(`Invalid univers'n name ${universName}`))
} else {
if (target.univers.length === 1) {
resolve('deleteTarget')
} else {
target.univers.splice(target.univers.indexOf(universName), 1)
resolve('dereferencedUnivers')
}
}
}
})
})
return promis
}
I call this promise here :
exports.deleteATarget = (req, res) => {
deleteUniversRefInTarget(req.params.universName, req.params.targetName)
.then((response) => {
console.log('Fin du traitement de la promesse')
if (response === 'deleteTarget') {
Target.findOneAndDelete({ name: req.params.targetName, univers: req.params.universName },
(err, target) => {
if (err) {
res.send(err)
}
res.json({ message: `Target ${target.name} isn't used in any univers, so we deleted it` })
})
} else {
res.json({ message: `Target ${req.params.targetName} no longer used in ${req.params.universName} univers` })
}
})
.catch((error) => {
res.send(error)
})
}
In the console, I can see :
Appel de deleteUniversRefInTarget
But not Fin du traitement de la promesse
So ... do you know what I'm doing bad ?

Answer 1

I'm not sure I understood everything, but here is my new code about this anti-pattern :
```
const deleteTargetOrDerefUniversInTarget = (universName, targetName) => {
const promis = new Promise((resolve, reject) => {
Target.findOne({ name: targetName, univers: universName })
.then((target) => {
if (target === null) {
reject(TypeError(`Invalid univers'n name ${universName} or target's name ${targetName}`))
} else if (target.univers.length === 1) {
resolve({ action: 'deleteTarget', target })
} else {
resolve({ action: 'dereferencedUnivers', target })
}
})
.catch((err) => {
reject(err)
})
})
return promis
}
exports.deleteATarget = (req, res) => {
deleteTargetOrDerefUniversInTarget(req.params.universName, req.params.targetName)
.then((response) => {
if (response.action === 'deleteTarget') {
Target.findOneAndDelete({ name: response.target.name, univers: req.params.universName })
.then((target) => {
res.json({ message: `Target ${target.name} isn't used in any univers, so we deleted it` })
})
.catch((err) => {
res.status(err.status).json(err)
})
} else {
response.target.univers.splice(response.target.univers.indexOf(req.params.universName), 1)
response.target.save()
res.json({ message: `Target ${response.target.name} no longer used in ${req.params.universName} univers` })
}
})
.catch((error) => {
res.send(error)
})
}
```
In this new code, no more exec call.
The first promise just send back an action to perform that the caller manage.

Answer 2

Ok, sounds much better when I transform my mongoose query (findOneAndUpdate) to a promise :
`
const deleteUniversRefInTarget = (universName, targetName) => {
console.log('Appel de deleteUniversRefInTarget')
const promis = new Promise((resolve, reject) => {
Target.findOneAndUpdate({ univers: universName, name: targetName })
.exec()
.then((target) =>{
console.log('Entrée dans la promesse')
if (target === null) {
reject(TypeError(`Invalid univers'n name ${universName}`))
} else {
if (target.univers.length === 1) {
resolve('deleteTarget')
} else {
target.univers.splice(target.univers.indexOf(universName), 1)
resolve('dereferencedUnivers')
}
}
})
.catch((err) => {
reject(err)
})
})
return promis
}
`
And the difference is mainly the .exec() part.
I think we can say it's solve ... even if I'm not sure it's the correct way to do ot.