npm package: @nailahq/mongoose-delete
Description: mongoose-soft-delete is simple and lightweight plugin that enables some basic required functionality for mongoose.
Latest version: 1.0.1

# Mongoose Soft Delete

mongoose-soft-delete is simple and lightweight plugin that enables some basic required functionality for mongoose.


## Features

- Soft Delete document using **destroy** method.

| Methods and Fields                          | Description                                                       |
| ------------------------------------------- | ----------------------------------------------------------------- |
| [ **destroy()** ](#simple-usage)            | method on document (do not override standard **remove()** method)
| [ **deleted**](#simple-usage)               | (true-false) key on document                                      |
| [ **deletedAt**](#save-time-of-deletion)    | Add key to store time of deletion                                 |


- Restore deleted documents using **restore** method

| Feature                                                                                | Description                                                        |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| [Bulk destroy and restore](#bulk-destroy-and-restore)                                  | Bulk Destroy                                                       |
| [Option to override static methods](#examples-how-to-override-one-or-multiple-methods) | **count, countDocuments, find, findOne, findOneAndUpdate, update** |
| [Disable model validation on destroy](#disable-model-validation-on-destroy)            | Disable Validation                                                 |
| [Option to create index on destroy fields](#create-index-on-fields)                    | **deleted**, **deletedAt**, **deletedBy**                          |

## Installation

Install using [npm](https://npmjs.org)

```
npm install mongoose-soft-delete
```

## Usage


### Setup

```javascript
const mongooseSoftDelete = require('mongoose-soft-delete');

const TestSchema = new Schema({
  name: String
});

// Apply on specific model.
// Can apply globally : eg: mongoose.plugin(mongooseSoftDelete, {})
TestSchema.plugin(mongooseSoftDelete, {
  paranoid: true,
});

const Test = mongoose.model('Test', TestSchema);
```

### Options

**paranoid** : it needs to be true for soft deletion.
### Simple usage

```javascript
const test = new Test({ name: 'Test' });
test.save(function() {
  test.destroy(function() {
    // deleted: true
    test.restore(function() {});
    //deleted: false
  });
});

var exampleTestId = mongoose.Types.ObjectId('53da93b16b4a6670076b16bf');

```

### Get sot soft deleted data.

```javascript
// pass *{ paranoid: false }* as option.
// This will return response including deleted documents.
test.find({ name: 'Arpit' }, null, { paranoid: false }, (err, user) => {});
```


### Bulk destroy and restore

```javascript

var idUser = mongoose.Types.ObjectId("53da93b16b4a6670076b16bf");

// destroy multiple object, callback
Test.destroy(function (err, result) { ... });
Test.destroy({age:10}, function (err, result) { ... });

// destroy multiple object, promise
Test.destroy().exec(function (err, result) { ... });
Test.destroy({age:10}).exec(function (err, result) { ... });

// Restore multiple object, callback
Test.restore(function (err, result) { ... });
Test.restore({age:10}, function (err, result) { ... });

// Restore multiple object, promise
Test.restore().exec(function (err, result) { ... });
Test.restore({age:10}).exec(function (err, result) { ... });
```

### Create index on fields

```javascript
TestSchema.plugin(mongooseSoftDelete, { indexFields: true });

// Index only specific fields
TestSchema.plugin(mongooseSoftDelete, {
  indexFields: ['deleted', 'deletedBy']
});
// or
TestSchema.plugin(mongooseSoftDelete, { indexFields: ['deletedAt'] });
```

### Method overridden

We have the option to override all standard methods or only specific methods. Overridden methods will exclude deleted documents from results, documents that have `deleted = true`. Every overridden method will have two additional methods, so we will be able to work with deleted documents.

**NOTE :** Method will be overridden if **paranoid is true**

| only not deleted documents |
| -------------------------- |
| count()                    |
| find()                     |
| findOne()                  |
| findOneAndUpdate()         |
| update()                   |