1. module mongoose-delete
   1. function mongoose-delete (schema, options)

module mongoose-delete

function mongoose-delete (schema, options)

• description and source-code

  mongoose-delete = function (schema, options) {
      options = options || {};
      var indexFields = parseIndexFields(options)
  
      schema.add({
          deleted: {
              type: Boolean,
              default: false,
              index: indexFields.deleted
          }
      });
  
      if (options.deletedAt === true) {
          schema.add({ deletedAt: { type: Date, index: indexFields.deletedAt }});
      }
  
      if (options.deletedBy === true) {
          schema.add({ deletedBy: { type: Schema.Types.ObjectId, index: indexFields.deletedBy }});
      }
  
      schema.pre('save', function (next) {
          if (!this.deleted) {
              this.deleted = false;
          }
          next();
      });
  
      if (options.overrideMethods) {
          var overrideItems = options.overrideMethods;
          var overridableMethods = ['count', 'find', 'findOne', 'findOneAndUpdate', 'update'];
          var finalList = [];
  
          if ((typeof overrideItems === 'string' || overrideItems instanceof String) && overrideItems === 'all') {
              finalList = overridableMethods;
          }
  
          if (typeof(overrideItems) === "boolean" && overrideItems === true) {
              finalList = overridableMethods;
          }
  
          if (Array.isArray(overrideItems)) {
              overrideItems.forEach(function(method) {
                  if (overridableMethods.indexOf(method) > -1) {
                      finalList.push(method);
                  }
              });
          }
  
          finalList.forEach(function(method) {
              if (method === 'count' || method === 'find' || method === 'findOne') {
                  schema.statics[method] = function () {
                      return Model[method].apply(this, arguments).where('deleted').ne(true);
                  };
                  schema.statics[method + 'Deleted'] = function () {
                      return Model[method].apply(this, arguments).where('deleted').ne(false);
                  };
                  schema.statics[method + 'WithDeleted'] = function () {
                      return Model[method].apply(this, arguments);
                  };
              } else {
                  schema.statics[method] = function () {
                      var args = parseUpdateArguments.apply(undefined, arguments);
  
                      args[0].deleted = {'$ne': true};
  
                      return Model[method].apply(this, args);
                  };
  
                  schema.statics[method + 'Deleted'] = function () {
                      var args = parseUpdateArguments.apply(undefined, arguments);
  
                      args[0].deleted = {'$ne': false};
  
                      return Model[method].apply(this, args);
                  };
  
                  schema.statics[method + 'WithDeleted'] = function () {
                      return Model[method].apply(this, arguments);
                  };
              }
          });
      }
  
      schema.methods.delete = function (deletedBy, cb) {
          var callback = typeof deletedBy === 'function' ? deletedBy : cb,
              deletedBy = cb !== undefined ? deletedBy : null;
  
          this.deleted = true;
  
          if (schema.path('deletedAt')) {
              this.deletedAt = new Date();
          }
  
          if (schema.path('deletedBy')) {
              this.deletedBy = deletedBy;
          }
  
          if (options.validateBeforeDelete === false) {
              return this.save({ validateBeforeSave: false }, callback);
          }
  
          return this.save(callback);
      };
  
      schema.statics.delete =  function (conditions, deletedBy, callback) {
          if (typeof deletedBy === 'function') {
              callback = deletedBy;
              conditions = conditions;
              deletedBy = null;
          } else if (typeof conditions === 'function') {
              callback = conditions;
              conditions = {};
              deletedBy = null;
          }
  
          var doc = {
              deleted: true
          };
  
          if (schema.path('deletedAt')) {
              doc.deletedAt = new Date();
          }
  
          if (schema.path('deletedBy')) {
              doc.deletedBy = deletedBy;
          }
  
          if (this.updateWithDeleted) {
              return this.updateWithDeleted(c ...

• example usage

  n/a