mongoose-soft-delete-plugin

A Mongoose plugin that adds soft delete functionality and active/inactive status to your Mongoose models, enabling efficient data management without permanently removing documents from the database.

Features

• Soft Delete: Mark documents as deleted without removing them from the database.
• Active/Inactive Status: Easily manage the state of documents with active and inactive flags.
• Flexible Querying: Find non-deleted and active documents effortlessly.
• Middleware Support: Automatically filter out deleted and inactive documents in query operations.
• Restore Functionality: (Optional) Restore soft-deleted documents while managing their active state.

Installation

To install the plugin, run:

1npm install mongoose-soft-delete-plugin

Usase

After installing the package, you can easily integrate it into your Mongoose schema by following these steps:

Step 1: Add the plugin to your schema.

First, define a Mongoose schema and apply the mongoose-soft-delete-plugin plugin to it:

1const mongoose = require('mongoose');
2const softDeletePlugin = require('mongoose-soft-delete-plugin');
3
4// Define your schema
5const userSchema = new mongoose.Schema({
6  name: { type: String, required: true },
7  email: { type: String, required: true, unique: true }
8});
9
10// Apply the soft delete plugin
11userSchema.plugin(softDeletePlugin);
12
13// Create the model
14const User = mongoose.model('User', userSchema);
15

Step 2: Soft Delete a Document. Once you’ve applied the plugin, you can soft delete a document by calling the softDelete method on a Mongoose model instance:

1async function softDeleteUser(userId) {
2  const user = await User.findById(userId);
3  if (user) {
4    await user.softDelete();
5    console.log('User soft deleted:', user);
6  }
7}
8

Step 3: Deactivate a Document. To deactivate a document (mark it as inactive), use the deactivate method:

1async function deactivateUser(userId) {
2  const user = await User.findById(userId);
3  if (user) {
4    await user.deactivate();
5    console.log('User deactivated:', user);
6  }
7}
8

Step 4: Activate a Document.

You can reactivate a previously deactivated document using the activate method:

1async function activateUser(userId) {
2  const user = await User.findById(userId);
3  if (user) {
4    await user.activate();
5    console.log('User activated:', user);
6  }
7}
8

Step 5: Query Active, Non-Deleted Documents.

The plugin provides a method findActiveNonDeleted to query only the documents that are both active and not soft deleted:

1async function getActiveUsers() {
2  const activeUsers = await User.findActiveNonDeleted();
3  console.log('Active and non-deleted users:', activeUsers);
4}
5

Step 6: Use Middleware for Filtering.

By default, the plugin adds middleware that filters out soft-deleted and inactive documents when you use find or findOne queries:

1async function findUsers() {
2  const users = await User.find();
3  console.log('Filtered users (non-deleted and active only):', users);
4}
5

Step 7: Restore Soft-Deleted Documents (Optional).

If you want to restore a soft-deleted document, simply update its isDeleted field back to false:

1async function restoreUser(userId) {
2  const user = await User.findById(userId);
3  if (user && user.isDeleted) {
4    user.isDeleted = false;
5    user.deletedAt = null;
6    await user.save();
7    console.log('User restored:', user);
8  }
9}
10

Example

Here’s a complete example showing how to use the plugin with a User model:

1const mongoose = require('mongoose');
2const softDeletePlugin = require('mongoose-soft-delete-plugin');
3
4// Define schema
5const userSchema = new mongoose.Schema({
6  name: { type: String, required: true },
7  email: { type: String, required: true, unique: true }
8});
9
10// Apply the soft delete plugin
11userSchema.plugin(softDeletePlugin);
12
13// Create the model
14const User = mongoose.model('User', userSchema);
15
16async function run() {
17  await mongoose.connect('mongodb://localhost:27017/testDB');
18
19  // Create a user
20  const user = new User({ name: 'John Doe', email: 'john@example.com' });
21  await user.save();
22  console.log('User created:', user);
23
24  // Soft delete the user
25  await user.softDelete();
26  console.log('User soft deleted:', user);
27
28  // Find all active, non-deleted users
29  const activeUsers = await User.findActiveNonDeleted();
30  console.log('Active users:', activeUsers);
31  
32  await mongoose.connection.close();
33}
34
35run().catch(console.error);
36

---

Key Sections in the Usage:

1. Step 1: Add the Plugin to Your Schema: Explains how to add the plugin to a Mongoose schema.
2. Step 2: Soft Delete a Document: Shows how to use the soft delete method.
3. Step 3: Deactivate a Document: Demonstrates how to deactivate a document.
4. Step 4: Activate a Document: Reactivate a previously deactivated document.
5. Step 5: Query Active, Non-Deleted Documents: Use the findActiveNonDeleted method for querying active, non-deleted data.
6. Step 6: Use Middleware for Filtering: Automatically exclude soft-deleted or inactive documents from standard find queries.
7. Step 7: Restore Soft-Deleted Documents (Optional): Explains how to manually restore a soft-deleted document.

This structure ensures that users of your plugin have a clear, step-by-step guide on how to integrate and use the plugin in their own projects!