Sequelize.js ¿eliminar consulta?

¿Hay alguna forma de escribir una consulta delete / deleteAll como findAll?

Por ejemplo, quiero hacer algo como esto (asumiendo que MyModel es un modelo Sequelize ...):

MyModel.deleteAll({ where: ['some_field != ?', something] })
    .on('success', function() { /* ... */ });

Para cualquiera que use Sequelize versión 3 y superior, use:

Model.destroy({
    where: {
        // criteria
    }
})

Sequelize Documentation - Tutorial de Sequelize

He buscado profundamente en el código, paso a paso, en los siguientes archivos:

https://github.com/sdepold/sequelize/blob/master/test/Model/destroy.js

https://github.com/sdepold/sequelize/blob/master/lib/model.js#L140

https://github.com/sdepold/sequelize/blob/master/lib/query-interface.js#L207-217

https://github.com/sdepold/sequelize/blob/master/lib/connectors/mysql/query-generator.js

Lo que encontré:

No hay un método deleteAll, hay un método destroy () al que puede llamar en un registro, por ejemplo:

Project.find(123).on('success', function(project) {
  project.destroy().on('success', function(u) {
    if (u && u.deletedAt) {
      // successfully deleted the project
    }
  })
})

No sé si la pregunta sigue siendo relevante, pero encontré lo siguiente en la documentación de Sequelize.

User.destroy('`name` LIKE "J%"').success(function() {
    // We just deleted all rows that have a name starting with "J"
})

http://sequelizejs.com/blog/state-of-v1-7-0

¡Espero eso ayude!

Este ejemplo muestra cómo hacer promesas en lugar de devolución de llamada.

Model.destroy({
   where: {
      id: 123 //this will be your id that you want to delete
   }
}).then(function(rowDeleted){ // rowDeleted will return number of rows deleted
  if(rowDeleted === 1){
     console.log('Deleted successfully');
   }
}, function(err){
    console.log(err); 
});

Consulte este enlace para obtener más información http://docs.sequelizejs.com/en/latest/api/model/#destroyoptions-promiseinteger

En la nueva versión, puedes probar algo como esto

function (req,res) {    
        model.destroy({
            where: {
                id: req.params.id
            }
        })
        .then(function (deletedRecord) {
            if(deletedRecord === 1){
                res.status(200).json({message:"Deleted successfully"});          
            }
            else
            {
                res.status(404).json({message:"record not found"})
            }
        })
        .catch(function (error){
            res.status(500).json(error);
        });

Aquí hay un ejemplo de ES6 usando Await / Async:

    async deleteProduct(id) {

        if (!id) {
            return {msg: 'No Id specified..', payload: 1};
        }

        try {
            return !!await products.destroy({
                where: {
                    id: id
                }
            });
        } catch (e) {
            return false;
        }

    }

Tenga en cuenta que estoy usando el !!operador Bang Bang en el resultado de la espera que cambiará el resultado a un booleano.

Escribí algo como esto para Sails hace un tiempo, en caso de que te ahorre algo de tiempo:

Uso de ejemplo:

// Delete the user with id=4
User.findAndDelete(4,function(error,result){
  // all done
});

// Delete all users with type === 'suspended'
User.findAndDelete({
  type: 'suspended'
},function(error,result){
  // all done
});

Fuente:

/**
 * Retrieve models which match `where`, then delete them
 */
function findAndDelete (where,callback) {

    // Handle *where* argument which is specified as an integer
    if (_.isFinite(+where)) {
        where = {
            id: where
        };
    }

    Model.findAll({
        where:where
    }).success(function(collection) {
        if (collection) {
            if (_.isArray(collection)) {
                Model.deleteAll(collection, callback);
            }
            else {
                collection.destroy().
                success(_.unprefix(callback)).
                error(callback);
            }
        }
        else {
            callback(null,collection);
        }
    }).error(callback);
}

/**
 * Delete all `models` using the query chainer
 */
deleteAll: function (models) {
    var chainer = new Sequelize.Utils.QueryChainer();
    _.each(models,function(m,index) {
        chainer.add(m.destroy());
    });
    return chainer.run();
}

a partir de: orm.js .

¡Espero que ayude!

1. la mejor manera de eliminar un registro es encontrarlo en primer lugar (si existe en la base de datos al mismo tiempo que desea eliminarlo)
2. mira este código

const StudentSequelize = require("../models/studientSequelize");
const StudentWork = StudentSequelize.Student;

const id = req.params.id;
    StudentWork.findByPk(id) // here i fetch result by ID sequelize V. 5
    .then( resultToDelete=>{
        resultToDelete.destroy(id); // when i find the result i deleted it by destroy function
    })
    .then( resultAfterDestroy=>{
        console.log("Deleted :",resultAfterDestroy);
    })
    .catch(err=> console.log(err));

Eliminar todo, sin condiciones:

Model.destroy({
    truncate: true,
})