from django.db import models
from django.utils import timezone
class SoftDeleteQuerySet(models.QuerySet):
def delete(self):
return super().update(deleted_at=timezone.now())
def hard_delete(self):
return super().delete()
def alive(self):
return self.filter(deleted_at__isnull=True)
def dead(self):
return self.filter(deleted_at__isnull=False)
class SoftDeleteManager(models.Manager.from_queryset(SoftDeleteQuerySet)):
def get_queryset(self):
return super().get_queryset().filter(deleted_at__isnull=True)
class AllObjectsManager(models.Manager.from_queryset(SoftDeleteQuerySet)):
def get_queryset(self):
return super().get_queryset()
class SoftDeleteModel(models.Model):
deleted_at = models.DateTimeField(null=True, blank=True, db_index=True, editable=False)
objects = SoftDeleteManager()
all_objects = AllObjectsManager()
class Meta:
abstract = True
def delete(self, using=None, keep_parents=False):
self.deleted_at = timezone.now()
self.save(using=using, update_fields=["deleted_at"])
def hard_delete(self, using=None, keep_parents=False):
return super().delete(using=using, keep_parents=keep_parents)
def restore(self):
self.deleted_at = None
self.save(update_fields=["deleted_at"])
@property
def is_deleted(self):
return self.deleted_at is not None
from django.conf import settings
from django.db import models
from .soft_delete import SoftDeleteModel
class Document(SoftDeleteModel):
owner = models.ForeignKey(
settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
related_name="documents",
)
slug = models.SlugField(max_length=120)
title = models.CharField(max_length=200)
body = models.TextField(blank=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
ordering = ["-created_at"]
# Slug must be unique only among live documents; a restore may collide.
constraints = [
models.UniqueConstraint(
fields=["owner", "slug"],
condition=models.Q(deleted_at__isnull=True),
name="unique_live_document_slug_per_owner",
)
]
def __str__(self):
return self.title
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.views.decorators.http import require_POST
from .models import Document
@login_required
def document_list(request):
# objects manager already excludes soft-deleted rows.
documents = Document.objects.filter(owner=request.user)
return render(request, "documents/list.html", {"documents": documents})
@login_required
@require_POST
def document_delete(request, pk):
document = get_object_or_404(Document, pk=pk, owner=request.user)
document.delete() # soft delete
return redirect("document_list")
@login_required
@require_POST
def document_restore(request, pk):
# Reach through all_objects to find the tombstoned row.
document = get_object_or_404(
Document.all_objects.dead(), pk=pk, owner=request.user
)
document.restore()
return JsonResponse({"id": document.pk, "restored": True})
Soft-deleting means marking a row as gone instead of issuing a DELETE, which preserves history, keeps foreign keys intact, and makes recovery trivial. The challenge in Django is making the rest of the codebase behave as if deleted rows do not exist, without sprinkling .filter(deleted_at__isnull=True) everywhere. This snippet solves that with a custom QuerySet, a manager built from it, and an abstract base model that ties them together.
In soft_delete.py, SoftDeleteQuerySet overrides delete() so calling it on a queryset performs a bulk UPDATE that stamps deleted_at, returning a count to mimic the real API. It also adds alive() and dead() scopes and a hard_delete() escape hatch that calls the genuine QuerySet.delete. The SoftDeleteManager is created via SoftDeleteQuerySet.as_manager() but its get_queryset() is filtered to deleted_at__isnull=True, so the default manager only ever sees live rows. A second AllObjectsManager returns everything, which is essential because an unfiltered manager is needed for the admin, for auditing, and to avoid subtle bugs when unrelated code assumes objects is complete.
The abstract SoftDeleteModel wires this together: objects hides deleted rows while all_objects exposes them. Its instance-level delete() sets deleted_at and saves rather than deleting, and restore() reverses it. Ordering the managers matters — the first declared manager becomes _default_manager, which Django uses for related lookups and some internal operations, so keeping the filtered one first means reverse relations also hide dead rows.
In models.py, Document simply inherits the base and gains soft-delete for free, including a unique_together that only makes sense against live rows. views.py shows the payoff: Document.objects.all() naturally excludes deleted records in the list view, while a restore endpoint reaches through all_objects to find the tombstoned row and revive it.
The main trade-off is that unique constraints and cascades no longer behave automatically — uniqueness must account for the tombstone, and cascading a parent's soft-delete to children requires explicit handling. This pattern fits domains where deletion is really an audit event, not a purge.
Related snips
import os
import stat
for root, _dirs, files in os.walk('/etc'):
for name in files:
path = os.path.join(root, name)Python security audit script for exposed risky filesystem state
class Product(models.Model):
name = models.CharField(max_length=200)
slug = models.SlugField(blank=True)
price = models.DecimalField(max_digits=10, decimal_places=2)
cost = models.DecimalField(max_digits=10, decimal_places=2)
margin = models.DecimalField(max_digits=5, decimal_places=2, blank=True)Django model signals vs overriding save
from django.urls import path
from . import views
app_name = 'blog'
urlpatterns = [Django URL namespacing and reverse lookups
import graphene
from graphene_django import DjangoObjectType
from blog.models import Post, Comment
class PostType(DjangoObjectType):Django GraphQL with Graphene
class AddSettingsToAccounts < ActiveRecord::Migration[7.1]
disable_ddl_transaction!
def change
add_column :accounts, :settings, :jsonb, null: false, default: {}Postgres JSONB Partial Index for Feature Flags
module EmailNormalization
extend ActiveSupport::Concern
included do
attr_accessor :soft_warningsSoft Validation: Normalize + Validate Email
Share this code
Here's the card — post it anywhere.
