Hapus lunak di mongodb node js

Di plugin asli, model dihapus hanya dengan referensi tanggal. Versi ini mengambil itu dan menggunakan bendera Boolean untuk menandai model yang dihapus/dipulihkan. Menambahkan bidang deletedAt untuk merekam saat dokumen dihapus. Selain itu, menghilangkan banyak overhead dari kode asli dan tidak menggunakan Coffeescript untuk kode asli

kita dapat menerapkan soft delete dengan plugin, middleware dan metode dokumen $isDeleted

kode plugin hapus lunak

import mongoose from 'mongoose';

export type TWithSoftDeleted = {
  isDeleted: boolean;
  deletedAt: Date | null;
}

type TDocument = TWithSoftDeleted & mongoose.Document;

const softDeletePlugin = (schema: mongoose.Schema) => {
  schema.add({
    isDeleted: {
      type: Boolean,
      required: true,
      default: false,
    },
    deletedAt: {
      type: Date,
      default: null,
    },
  });

  const typesFindQueryMiddleware = [
    'count',
    'find',
    'findOne',
    'findOneAndDelete',
    'findOneAndRemove',
    'findOneAndUpdate',
    'update',
    'updateOne',
    'updateMany',
  ];

  const setDocumentIsDeleted = async (doc: TDocument) => {
    doc.isDeleted = true;
    doc.deletedAt = new Date();
    doc.$isDeleted(true);
    await doc.save();
  };

  const excludeInFindQueriesIsDeleted = async function (
    this: mongoose.Query,
    next: mongoose.HookNextFunction
  ) {
    this.where({ isDeleted: false });
    next();
  };

  const excludeInDeletedInAggregateMiddleware = async function (
    this: mongoose.Aggregate,
    next: mongoose.HookNextFunction
  ) {
    this.pipeline().unshift({ $match: { isDeleted: false } });
    next();
  };

  schema.pre('remove', async function (
    this: TDocument,
    next: mongoose.HookNextFunction
  ) {
    await setDocumentIsDeleted(this);
    next();
  });

  typesFindQueryMiddleware.forEach((type) => {
    schema.pre(type, excludeInFindQueriesIsDeleted);
  });

  schema.pre('aggregate', excludeInDeletedInAggregateMiddleware);
};

export {
  softDeletePlugin,
};

Anda dapat menggunakan global untuk semua skema

mongoose.plugin(softDeletePlugin);

atau untuk skema konkret

Bagaimana cara melakukan soft delete menggunakan nodejs di mongodb

misalnya pake kode ini bisa dimodif jadi soft delete atau ada cara lain?

Pengontrol/ kategori. js

exports.remove = (req, res) => {
    const category = req.category;
    category.remove((error, data) => {
        if (error) {
            return res.status(400).json({
                error: errorHandler(error)
            });
        }
        res.json({
            message: "Category deleted"
        });
    });
};

rute/kategori. js

const express = require("express");
const router = express.Router();

const { create, categoryById, read, update, remove, list } = require("../controllers/category");
const { requireSignin, isAuth, isAdmin } = require("../controllers/auth");
const { userById } = require("../controllers/user");

router.get("/category/:categoryId", read);
router.post("/category/create/:userId", requireSignin, isAuth, isAdmin, create);
router.put("/category/:categoryId/:userId", requireSignin, isAuth, isAdmin, update);
router.delete("/category/:categoryId/:userId", requireSignin, isAuth, isAdmin, remove);
router.post("/categories", list);

router.param("categoryId", categoryById);
router.param("userId", userById);

module.exports = router;

model/kategori. js

const mongoose = require("mongoose");

const categorySchema = new mongoose.Schema(
    {
        name: {
            type: String,
            trim: true,
            required: true,
            maxlength: 32
        }
    },
    { timestamps: true }
);

module.exports = mongoose.model("Category", categorySchema);

Metode deleteMany() mengembalikan objek yang berisi informasi tentang bagaimana eksekusi memengaruhi database

Sebagian besar informasi tidak penting untuk dipahami, tetapi satu objek di dalam objek disebut "hasil" yang memberi tahu kita jika eksekusi berjalan baik, dan berapa banyak dokumen yang terpengaruh

mongoose-soft-delete adalah plugin sederhana dan ringan yang memungkinkan beberapa fungsionalitas dasar yang diperlukan untuk luwak

Fitur

• Soft Hapus dokumen menggunakan metode penghancuran

• Pulihkan dokumen yang dihapus menggunakan metode pemulihan

Instalasi

Instal menggunakan npm

npm install mongoose-soft-delete

Penggunaan

Mempersiapkan

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);

Pilihan

paranoid. itu harus benar untuk penghapusan lunak

Penggunaan sederhana

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');
 

Dapatkan data yang dihapus dengan lembut

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

Penghancuran dan pemulihan massal

 
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) { ... });

Buat indeks pada bidang

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

Metode diganti

Kami memiliki opsi untuk mengganti semua metode standar atau hanya metode tertentu. Metode yang diganti akan mengecualikan dokumen yang dihapus dari hasil, dokumen yang memiliki deleted = true. Setiap metode yang diganti akan memiliki dua metode tambahan, sehingga kami dapat bekerja dengan dokumen yang dihapus

Apa itu soft delete di MongoDB?

Apa itu soft delete di node JS?

Bagaimana cara menghapus data dari MongoDB menggunakan Nodejs?

Apa itu soft delete dan hard delete di MongoDB?